Houdini EXPOSED

Subject: Houdini EXPOSED Tue Oct 11, 2011 3:01 pm

[You must be registered and logged in to see this link.]
22 minutes ago
Computer
Chess Biggest Liar Postby kingliveson » Tue Oct 11, 2011 1:11 pm The
competition is pretty stiff if you asked me. So Robert said there are no
IPPOLIT codes in Houdini... Again, Houdini is RobboLito modified. Shall
we start from main and compare Houdini 1.0 (build 2010-05-15) to
RobboLito? Some of the differences you will see if you looked at the
assembly/disassembly are due to slight modification and combined
routines, compiler, and optimization flags.

Houdini is RobboLito modified.

Shall we start from main and compare Houdini 1.0 (build 2010-05-15) to
RobboLito? Some of the differences you will see if you looked at the
assembly/disassembly are due to slight modification and combined
routines, compiler, and optimization flags.

Here is Houdini's main():

Code: Select all
int cdecl main(int argc, const char argv, const char envp)
{
int v3; ecx@1
int v4; eax@1
DWORD v5; ecx@1
struct _SYSTEM_INFO SystemInfo; [sp+4h] [bp-24h]@1

sub_12A8B5A("Houdini w32 1_CPUnbuild %d-%.2d-%.2d nby Robert Houdartn", 2010);
v4 = sub_12A87BF(v3);
fflush((FILE *)(v4 + 32));
GetSystemInfo(&SystemInfo);
v5 = SystemInfo.dwNumberOfProcessors;
dword_17A6878 = SystemInfo.dwNumberOfProcessors;
if ( (signed int32)SystemInfo.dwNumberOfProcessors > 1 )
v5 = 1;
dword_12BCED0 = v5;
dword_13040C8 = 0;
if ( (signed int)v5 > 0 )
{
dword_13040C8 = (int)_aligned_malloc(0x200000u, 0x40u);
memset((void *)dword_13040C8, 0, 0x200000u);
}
sub_128F0D0(128);
memset32(word_177B368, 134219776, 0x200u);
sub_1289310();
sub_12A1F80();
_cfltcvt_init();
sub_12A8340();
sub_128F760();
sub_12A40A0();
sub_12A74B0(1);
while ( 1 )
sub_12A6470();
}

For comparison, here are 3 different builds of RobboLito

085g3 (Intel):

Code: Select all
int cdecl main(int argc, const char argv, const char envp)
{
unsigned int v3; eax@1
m128i v4; xmm0@1

intel_new_proc_init(0);
sub_428FF0();
dword_4886C4 = (int)malloc(0x200000u);
sub_435970((void *)dword_4886C4, 0, 0x200000u);
sub_434DD0(128);
v3 = 0;
v4 = _mm_shuffle_epi32(_mm_cvtsi32_si128(0x8000800u), 0);
do
{
_mm_store_si128((m128i *)&xmmword_79E720[2 * v3 / 0x10], v4);
_mm_store_si128((m128i *)&xmmword_79E730[2 * v3 / 0x10], v4);
_mm_store_si128((m128i *)&xmmword_79E740[2 * v3 / 0x10], v4);
_mm_store_si128((m128i *)&xmmword_79E750[2 * v3 / 0x10], v4);
v3 += 32;
}
while ( v3 < 0x400 );
sub_40CF30();
sub_423210();
sub_41A3E0();
sub_433A10();
sub_426CF0();
sub_428E50(1u);
while ( 1 )
sub_428560();
}

085g3 (MS):

Code: Select all
int cdecl main(int argc, const char argv, const char envp)
{
FILE *v3; eax@1
int v4; edx@1
int v5; ecx@1

printf("RobboLito 0.085g3 w32nOct 10 2011 23:41:06nwindows version by kranium and sentineln");
v3 = _iob_func();
fflush(v3 + 1);
dword_47B628 = (int)malloc(0x200000u);
memset((void *)dword_47B628, 0, 0x200000u);
sub_427560(v5, v4);
memset32(&word_62B1C0, 134219776, 0x200u);
sub_403320();
sub_41A5F0();
sub_412C60();
sub_427180();
sub_41CEA0();
sub_420230();
while ( 1 )
sub_41EC00();
}

009:

Code: Select all
int cdecl main(int argc, const char argv, const char envp)
{
int v3; ecx@1
int v4; eax@1
signed int v5; esi@1
int v6; // [sp+0h] [bp-8h]@0

sub_4274E8(
(int)"RobboLito 0.09 w32nDec 31 2009 16:51:46nbasic windows version by kranium, improved by sentineln",
v6);
v4 = sub_42714D(v3);
fflush((FILE *)(v4 + 32));
dword_44CBB0 = (int)malloc(0x200000u);
memset((void *)dword_44CBB0, 0, 0x200000u);
sub_408530(128);
memset32(&word_6FA420, 134219776, 0x200u);
sub_409630();
sub_41FD30();
sub_418870();
v5 = 0;
do
sub_426BF0(v5++);
while ( v5 < 419904 );
sub_422920();
sub_425740();
while ( 1 )
sub_424130();
}

Here is RobboLIto's main() (main.c):

Code: Select all
int main()
{
show_version();
pawn_zobrist_initialization();
initialization_zobrist(128);
history_reset();
initialization_capture();
pile_initialization();
pawn_initialization();
initialization_value();
static_initialization();
game_new(TRUE);

while( 1 )
input_console();
return 0;
}

As I stated earlier, I wasnt planning on doing this, and if at all, not
until maybe December, but in the main time, some additional info:

Houdini calls show_version() (utils.c):

Code: Select all
void show_version()
{
char *startup_banner =
"" NAME "n"
"" DATE " " TIME__ "n"
"windows version by kranium and sentineln";

printf(startup_banner);
fflush(stdout);
}

The date format has been modified slightly in Houdini and the text, "build," added:

Code: Select all
Houdini w32 1_CPU
build 2010-05-15
by Robert Houdart

RobboLito 0.085g3 w32
Oct 10 2011 22:46:33
windows version by kranium and sentinel

[You must be registered and logged in to see this image.]

[You must be registered and logged in to see this link.]

re: continued
[You must be registered and logged in to see this link.]
19 minutes ago

Houdini also calls check_num_CPU() (utils.c):

Code: Select all
int check_num_CPU()
{
int num_CPU;
SYSTEM_INFO sysinfo;
GetSystemInfo( &sysinfo );
num_CPU = sysinfo.dwNumberOfProcessors;
return num_CPU;
}

The above is just a generic way of getting the number of CPUs in Windows
OS. What Houdini does here is set the number of CPU to 1 if the system
has more.

Houdini Initializes pawnhash:

Code: Select all
{
dword_13040C8 = (int)_aligned_malloc(0x200000u, 0x40u);
memset((void *)dword_13040C8, 0, 2097152u);
}

RobboLito's pawn_zobrist_initialization() (main.c):

Code: Select all
static void pawn_zobrist_initialization()
{
pawn_zobrist = malloc(list_pawn_number * sizeof(type_pawn_value));
memset(pawn_zobrist, 0, list_pawn_number * sizeof(type_pawn_value));
}

[You must be registered and logged in to see this image.]

[You must be registered and logged in to see this link.]

re: continued
[You must be registered and logged in to see this link.]
17 minutes ago

Houdini then calls initialization_zobrist(). Hash size in the RobboLito
version Norm mentioned is left unchanged in Houdini sub_128F0D0(128):

Code: Select all
int cdecl sub_128F0D0(int a1)
{
int v6; esi@1
int v7; edi@1
size_t v8; esi@3
int result; eax@3

asm { bsr eax, [esp+arg_0] }
v6 = ((1 << _EAX) & 0xFFF) << 16;
dword_12BCFA0 = v6;
dword_12BCFA4 = 0;
v7 = 16 * (unsigned int64)(unsigned int)v6 >> 20;
dword_13040C0 = v6 - 4;
if ( byte_17B3648 )
_aligned_free(Memory);
v8 = 16 * v6;
byte_17B3648 = 1;
Memory = _aligned_malloc(v8, 0x40u);
memset(Memory, 0, v8);
memset(&unk_1304AC0, 0, 0x100000u);
result = v7;
dword_13040CC = 0;
return result;
}

RobboLito's initialization_zobrist() (zobrist.c):

Code: Select all
int initialization_zobrist( int mb )
{
YEARS = 0;
zobrist_dimension = ((1 << BSR(mb)) << 20) / sizeof(type_zobrist);

if( zobrist_dimension > 0x100000000 )
zobrist_dimension = 0x100000000;
mb = (zobrist_dimension * sizeof(type_zobrist)) >> 20;
list_hide = zobrist_dimension - 4;

if( zobrist_initialization_flag )
free(list_zobrist);
zobrist_initialization_flag = TRUE;
list_zobrist = malloc(zobrist_dimension * sizeof(type_zobrist));
zobrist_free();
return mb;
}

Houdini call history_reset:

Code: Select all
memset32(word_177B368, 134219776, 0x200u);

RobboLito:

Code: Select all
memset32(&word_62B1C0, 134219776, 0x200u);

Houdini initializes capture:

Code: Select all
signed int cdecl sub_1289310()
{
signed int result; eax@1

dword_17B14CC = -836763648;
dword_17B150C = -836763648;
dword_17B14C8 = -970981376;
dword_17B1508 = -970981376;
result = 3188719616;
dword_17B1400 = 0xC0200000u;
dword_17B1440 = -1089470464;
dword_17B1404 = 0xC0200000u;
dword_17B1444 = -1089470464;
dword_17B140C = -803209216;
dword_17B144C = -819986432;
dword_17B154C = -853540864;
dword_17B158C = -871366656;
dword_17B148C = -889192448;
dword_17B1408 = -937426944;
dword_17B1448 = -954204160;
dword_17B1548 = -988807168;
dword_17B1588 = -1006632960;
dword_17B1488 = -1023410176;
dword_17B14C0 = 3188719616;
dword_17B1500 = 3188719616;
dword_17B1540 = -1124073472;
dword_17B1580 = -1140850688;
dword_17B1480 = -1157627904;
dword_17B14C4 = 3188719616;
dword_17B1504 = 3188719616;
dword_17B1544 = -1124073472;
dword_17B1584 = -1140850688;
dword_17B1484 = -1157627904;
dword_17B13F8 = -1205862400;
dword_17B1438 = -1223688192;
dword_17B14B8 = -1240465408;
dword_17B14F8 = -1240465408;
dword_17B1538 = -1258291200;
dword_17B1578 = -1275068416;
dword_17B1478 = -1291845632;
dword_17B13F4 = -1341128704;
dword_17B1434 = -1358954496;
dword_17B14B4 = -1375731712;
dword_17B14F4 = -1375731712;
dword_17B1534 = -1392508928;
dword_17B1574 = -1409286144;
dword_17B1474 = -1426063360;
dword_17B1450 = 117440512;
dword_17B13D0 = 100696064;
dword_17B1410 = 83918848;
dword_17B1490 = 67141632;
dword_17B14D0 = 67141632;
dword_17B1510 = 50364416;
dword_17B1550 = 33587200;
dword_17B15EC = -803209216;
dword_17B162C = -819986432;
dword_17B16AC = -836763648;
dword_17B16EC = -836763648;
dword_17B172C = -853540864;
dword_17B176C = -871366656;
dword_17B166C = -889192448;
dword_17B15E8 = -937426944;
dword_17B1628 = -954204160;
dword_17B16A8 = -970981376;
dword_17B16E8 = -970981376;
dword_17B1728 = -988807168;
dword_17B1768 = -1006632960;
dword_17B1668 = -1023410176;
dword_17B15E0 = -1071644672;
dword_17B1620 = -1089470464;
dword_17B16A0 = 3188719616;
dword_17B1660 = -1157627904;
dword_17B1664 = -1157627904;
dword_17B1698 = -1240465408;
dword_17B16D8 = -1240465408;
dword_17B1720 = -1124073472;
dword_17B1724 = -1124073472;
dword_17B1760 = -1140850688;
dword_17B1764 = -1140850688;
dword_17B16E0 = 3188719616;
dword_17B15E4 = -1071644672;
dword_17B1624 = -1089470464;
dword_17B16A4 = 3188719616;
dword_17B16E4 = 3188719616;
dword_17B15D8 = -1205862400;
dword_17B1618 = -1223688192;
dword_17B1718 = -1258291200;
dword_17B1758 = -1275068416;
dword_17B1658 = -1291845632;
dword_17B15D4 = -1341128704;
dword_17B1614 = -1358954496;
dword_17B1694 = -1375731712;
dword_17B16D4 = -1375731712;
dword_17B1714 = -1392508928;
dword_17B1754 = -1409286144;
dword_17B1654 = -1426063360;
dword_17B1650 = 117440512;
dword_17B15D0 = 100696064;
dword_17B1610 = 83918848;
dword_17B1690 = 67141632;
dword_17B16D0 = 67141632;
dword_17B1710 = 50364416;
dword_17B1750 = 33587200;
return result;
}

RobboLito's capture initialization:

Code: Select all
signed int __cdecl sub_403320()
{
signed int result; eax@1

dword_43A654 = -836763648;
dword_43A694 = -836763648;
dword_43A650 = -970981376;
dword_43A690 = -970981376;
result = -1106247680;
dword_43A588 = -1071644672;
dword_43A5C8 = -1089470464;
dword_43A6C8 = -1124073472;
dword_43A58C = -1071644672;
dword_43A5CC = -1089470464;
dword_43A6CC = -1124073472;
dword_43A594 = -803209216;
dword_43A5D4 = -819986432;
dword_43A6D4 = -853540864;
dword_43A714 = -871366656;
dword_43A590 = -937426944;
dword_43A5D0 = -954204160;
dword_43A6D0 = -988807168;
dword_43A710 = -1006632960;
dword_43A648 = -1106247680;
dword_43A688 = -1106247680;
dword_43A708 = -1140850688;
dword_43A64C = -1106247680;
dword_43A68C = -1106247680;
dword_43A70C = -1140850688;
dword_43A580 = -1205862400;
dword_43A5C0 = -1223688192;
dword_43A640 = -1240465408;
dword_43A680 = -1240465408;
dword_43A6C0 = -1258291200;
dword_43A700 = -1275068416;
dword_43A57C = -1341128704;
dword_43A5BC = -1358954496;
dword_43A63C = -1375731712;
dword_43A67C = -1375731712;
dword_43A6BC = -1392508928;
dword_43A6FC = -1409286144;
dword_43A614 = -889192448;
dword_43A610 = -1023410176;
dword_43A608 = -1157627904;
dword_43A60C = -1157627904;
dword_43A600 = -1291845632;
dword_43A5FC = -1426063360;
dword_43A5D8 = 117440512;
dword_43A558 = 100696064;
dword_43A598 = 83918848;
dword_43A618 = 67141632;
dword_43A658 = 67141632;
dword_43A698 = 50364416;
dword_43A6D8 = 33587200;
dword_43A774 = -803209216;
dword_43A7B4 = -819986432;
dword_43A834 = -836763648;
dword_43A874 = -836763648;
dword_43A8B4 = -853540864;
dword_43A8F4 = -871366656;
dword_43A770 = -937426944;
dword_43A7B0 = -954204160;
dword_43A830 = -970981376;
dword_43A870 = -970981376;
dword_43A8B0 = -988807168;
dword_43A8F0 = -1006632960;
dword_43A768 = -1071644672;
dword_43A7A8 = -1089470464;
dword_43A828 = -1106247680;
dword_43A868 = -1106247680;
dword_43A8A8 = -1124073472;
dword_43A8E8 = -1140850688;
dword_43A820 = -1240465408;
dword_43A860 = -1240465408;
dword_43A81C = -1375731712;
dword_43A85C = -1375731712;
dword_43A8EC = -1140850688;
dword_43A76C = -1071644672;
dword_43A7AC = -1089470464;
dword_43A82C = -1106247680;
dword_43A86C = -1106247680;
dword_43A8AC = -1124073472;
dword_43A760 = -1205862400;
dword_43A7A0 = -1223688192;
dword_43A8A0 = -1258291200;
dword_43A8E0 = -1275068416;
dword_43A75C = -1341128704;
dword_43A79C = -1358954496;
dword_43A89C = -1392508928;
dword_43A8DC = -1409286144;
dword_43A7F4 = -889192448;
dword_43A7F0 = -1023410176;
dword_43A7E8 = -1157627904;
dword_43A7EC = -1157627904;
dword_43A7E0 = -1291845632;
dword_43A7DC = -1426063360;
dword_43A7D8 = 117440512;
dword_43A758 = 100696064;
dword_43A798 = 83918848;
dword_43A818 = 67141632;
dword_43A858 = 67141632;
dword_43A898 = 50364416;
dword_43A8D8 = 33587200;
return result;
}

RobboLito initialization_capture() (nit.gen.h):

Code: Select all
void initialization_capture()
{
capture_value[count_pawn_white][count_queen_black] = (0xd0 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_queen_black] = (0xcf << 24) + (0x02 << 20);
capture_value[count_clear_white][count_queen_black] = (0xce << 24) + (0x02 << 20);
capture_value[count_dark_white][count_queen_black] = (0xce << 24) + (0x02 << 20);
capture_value[count_rook_white][count_queen_black] = (0xcd << 24) + (0x02 << 20);
capture_value[count_queen_white][count_queen_black] = (0xcc << 24) + (0x01 << 20);

capture_value[count_pawn_white][count_rook_black] = (0xc8 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_rook_black] = (0xc7 << 24) + (0x02 << 20);
capture_value[count_clear_white][count_rook_black] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_dark_white][count_rook_black] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_rook_white][count_rook_black] = (0xc5 << 24) + (0x01 << 20);
capture_value[count_queen_white][count_rook_black] = (0xc4 << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_clear_black] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_clear_black] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_white][count_clear_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_white][count_clear_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_white][count_clear_black] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_white][count_clear_black] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_dark_black] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_dark_black] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_white][count_dark_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_white][count_dark_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_white][count_dark_black] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_white][count_dark_black] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_knight_black] = (0xb8 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_knight_black] = (0xb7 << 24) + (0x01 << 20);
capture_value[count_clear_white][count_knight_black] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_dark_white][count_knight_black] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_rook_white][count_knight_black] = (0xb5 << 24) + (0x00 << 20);
capture_value[count_queen_white][count_knight_black] = (0xb4 << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_pawn_black] = (0xb0 << 24) + (0x01 << 20);
capture_value[count_knight_white][count_pawn_black] = (0xaf << 24) + (0x00 << 20);
capture_value[count_clear_white][count_pawn_black] = (0xae << 24) + (0x00 << 20);
capture_value[count_dark_white][count_pawn_black] = (0xae << 24) + (0x00 << 20);
capture_value[count_rook_white][count_pawn_black] = (0xad << 24) + (0x00 << 20);
capture_value[count_queen_white][count_pawn_black] = (0xac << 24) + (0x00 << 20);

capture_value[count_king_white][count_queen_black] = (0xcb << 24) + (0x00 << 20);
capture_value[count_king_white][count_rook_black] = (0xc3 << 24) + (0x00 << 20);
capture_value[count_king_white][count_clear_black] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_white][count_dark_black] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_white][count_knight_black] = (0xb3 << 24) + (0x00 << 20);
capture_value[count_king_white][count_pawn_black] = (0xab << 24) + (0x00 << 20);

capture_value[count_king_white][0] = (0x07 << 24) + (0x00 << 15);
capture_value[count_pawn_white][0] = (0x06 << 24) + (0x01 << 15);
capture_value[count_knight_white][0] = (0x05 << 24) + (0x01 << 15);
capture_value[count_clear_white][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_dark_white][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_rook_white][0] = (0x03 << 24) + (0x01 << 15);
capture_value[count_queen_white][0] = (0x02 << 24) + (0x01 << 15);

capture_value[count_pawn_black][count_queen_white] = (0xd0 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_queen_white] = (0xcf << 24) + (0x02 << 20);
capture_value[count_clear_black][count_queen_white] = (0xce << 24) + (0x02 << 20);
capture_value[count_dark_black][count_queen_white] = (0xce << 24) + (0x02 << 20);
capture_value[count_rook_black][count_queen_white] = (0xcd << 24) + (0x02 << 20);
capture_value[count_queen_black][count_queen_white] = (0xcc << 24) + (0x01 << 20);

capture_value[count_pawn_black][count_rook_white] = (0xc8 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_rook_white] = (0xc7 << 24) + (0x02 << 20);
capture_value[count_clear_black][count_rook_white] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_dark_black][count_rook_white] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_rook_black][count_rook_white] = (0xc5 << 24) + (0x01 << 20);
capture_value[count_queen_black][count_rook_white] = (0xc4 << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_clear_white] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_clear_white] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_black][count_clear_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_black][count_clear_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_black][count_clear_white] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_black][count_clear_white] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_dark_white] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_dark_white] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_black][count_dark_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_black][count_dark_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_black][count_dark_white] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_black][count_dark_white] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_knight_white] = (0xb8 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_knight_white] = (0xb7 << 24) + (0x01 << 20);
capture_value[count_clear_black][count_knight_white] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_dark_black][count_knight_white] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_rook_black][count_knight_white] = (0xb5 << 24) + (0x00 << 20);
capture_value[count_queen_black][count_knight_white] = (0xb4 << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_pawn_white] = (0xb0 << 24) + (0x01 << 20);
capture_value[count_knight_black][count_pawn_white] = (0xaf << 24) + (0x00 << 20);
capture_value[count_clear_black][count_pawn_white] = (0xae << 24) + (0x00 << 20);
capture_value[count_dark_black][count_pawn_white] = (0xae << 24) + (0x00 << 20);
capture_value[count_rook_black][count_pawn_white] = (0xad << 24) + (0x00 << 20);
capture_value[count_queen_black][count_pawn_white] = (0xac << 24) + (0x00 << 20);

capture_value[count_king_black][count_queen_white] = (0xcb << 24) + (0x00 << 20);
capture_value[count_king_black][count_rook_white] = (0xc3 << 24) + (0x00 << 20);
capture_value[count_king_black][count_clear_white] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_black][count_dark_white] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_black][count_knight_white] = (0xb3 << 24) + (0x00 << 20);
capture_value[count_king_black][count_pawn_white] = (0xab << 24) + (0x00 << 20);

capture_value[count_king_black][0] = (0x07 << 24) + (0x00 << 15);
capture_value[count_pawn_black][0] = (0x06 << 24) + (0x01 << 15);
capture_value[count_knight_black][0] = (0x05 << 24) + (0x01 << 15);
capture_value[count_clear_black][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_dark_black][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_rook_black][0] = (0x03 << 24) + (0x01 << 15);
capture_value[count_queen_black][0] = (0x02 << 24) + (0x01 << 15);
}

continued

1 - 2

[You must be registered and logged in to see this link.]

[You must be registered and logged in to see this link.]
16 minutes ago

capture_value[count_pawn_white][count_rook_black] = (0xc8 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_rook_black] = (0xc7 << 24) + (0x02 << 20);
capture_value[count_clear_white][count_rook_black] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_dark_white][count_rook_black] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_rook_white][count_rook_black] = (0xc5 << 24) + (0x01 << 20);
capture_value[count_queen_white][count_rook_black] = (0xc4 << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_clear_black] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_clear_black] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_white][count_clear_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_white][count_clear_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_white][count_clear_black] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_white][count_clear_black] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_dark_black] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_dark_black] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_white][count_dark_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_white][count_dark_black] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_white][count_dark_black] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_white][count_dark_black] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_knight_black] = (0xb8 << 24) + (0x02 << 20);
capture_value[count_knight_white][count_knight_black] = (0xb7 << 24) + (0x01 << 20);
capture_value[count_clear_white][count_knight_black] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_dark_white][count_knight_black] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_rook_white][count_knight_black] = (0xb5 << 24) + (0x00 << 20);
capture_value[count_queen_white][count_knight_black] = (0xb4 << 24) + (0x00 << 20);

capture_value[count_pawn_white][count_pawn_black] = (0xb0 << 24) + (0x01 << 20);
capture_value[count_knight_white][count_pawn_black] = (0xaf << 24) + (0x00 << 20);
capture_value[count_clear_white][count_pawn_black] = (0xae << 24) + (0x00 << 20);
capture_value[count_dark_white][count_pawn_black] = (0xae << 24) + (0x00 << 20);
capture_value[count_rook_white][count_pawn_black] = (0xad << 24) + (0x00 << 20);
capture_value[count_queen_white][count_pawn_black] = (0xac << 24) + (0x00 << 20);

capture_value[count_king_white][count_queen_black] = (0xcb << 24) + (0x00 << 20);
capture_value[count_king_white][count_rook_black] = (0xc3 << 24) + (0x00 << 20);
capture_value[count_king_white][count_clear_black] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_white][count_dark_black] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_white][count_knight_black] = (0xb3 << 24) + (0x00 << 20);
capture_value[count_king_white][count_pawn_black] = (0xab << 24) + (0x00 << 20);

capture_value[count_king_white][0] = (0x07 << 24) + (0x00 << 15);
capture_value[count_pawn_white][0] = (0x06 << 24) + (0x01 << 15);
capture_value[count_knight_white][0] = (0x05 << 24) + (0x01 << 15);
capture_value[count_clear_white][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_dark_white][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_rook_white][0] = (0x03 << 24) + (0x01 << 15);
capture_value[count_queen_white][0] = (0x02 << 24) + (0x01 << 15);

capture_value[count_pawn_black][count_queen_white] = (0xd0 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_queen_white] = (0xcf << 24) + (0x02 << 20);
capture_value[count_clear_black][count_queen_white] = (0xce << 24) + (0x02 << 20);
capture_value[count_dark_black][count_queen_white] = (0xce << 24) + (0x02 << 20);
capture_value[count_rook_black][count_queen_white] = (0xcd << 24) + (0x02 << 20);
capture_value[count_queen_black][count_queen_white] = (0xcc << 24) + (0x01 << 20);

capture_value[count_pawn_black][count_rook_white] = (0xc8 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_rook_white] = (0xc7 << 24) + (0x02 << 20);
capture_value[count_clear_black][count_rook_white] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_dark_black][count_rook_white] = (0xc6 << 24) + (0x02 << 20);
capture_value[count_rook_black][count_rook_white] = (0xc5 << 24) + (0x01 << 20);
capture_value[count_queen_black][count_rook_white] = (0xc4 << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_clear_white] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_clear_white] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_black][count_clear_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_black][count_clear_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_black][count_clear_white] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_black][count_clear_white] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_dark_white] = (0xc0 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_dark_white] = (0xbf << 24) + (0x01 << 20);
capture_value[count_clear_black][count_dark_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_dark_black][count_dark_white] = (0xbe << 24) + (0x01 << 20);
capture_value[count_rook_black][count_dark_white] = (0xbd << 24) + (0x00 << 20);
capture_value[count_queen_black][count_dark_white] = (0xbc << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_knight_white] = (0xb8 << 24) + (0x02 << 20);
capture_value[count_knight_black][count_knight_white] = (0xb7 << 24) + (0x01 << 20);
capture_value[count_clear_black][count_knight_white] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_dark_black][count_knight_white] = (0xb6 << 24) + (0x01 << 20);
capture_value[count_rook_black][count_knight_white] = (0xb5 << 24) + (0x00 << 20);
capture_value[count_queen_black][count_knight_white] = (0xb4 << 24) + (0x00 << 20);

capture_value[count_pawn_black][count_pawn_white] = (0xb0 << 24) + (0x01 << 20);
capture_value[count_knight_black][count_pawn_white] = (0xaf << 24) + (0x00 << 20);
capture_value[count_clear_black][count_pawn_white] = (0xae << 24) + (0x00 << 20);
capture_value[count_dark_black][count_pawn_white] = (0xae << 24) + (0x00 << 20);
capture_value[count_rook_black][count_pawn_white] = (0xad << 24) + (0x00 << 20);
capture_value[count_queen_black][count_pawn_white] = (0xac << 24) + (0x00 << 20);

capture_value[count_king_black][count_queen_white] = (0xcb << 24) + (0x00 << 20);
capture_value[count_king_black][count_rook_white] = (0xc3 << 24) + (0x00 << 20);
capture_value[count_king_black][count_clear_white] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_black][count_dark_white] = (0xbb << 24) + (0x00 << 20);
capture_value[count_king_black][count_knight_white] = (0xb3 << 24) + (0x00 << 20);
capture_value[count_king_black][count_pawn_white] = (0xab << 24) + (0x00 << 20);

capture_value[count_king_black][0] = (0x07 << 24) + (0x00 << 15);
capture_value[count_pawn_black][0] = (0x06 << 24) + (0x01 << 15);
capture_value[count_knight_black][0] = (0x05 << 24) + (0x01 << 15);
capture_value[count_clear_black][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_dark_black][0] = (0x04 << 24) + (0x01 << 15);
capture_value[count_rook_black][0] = (0x03 << 24) + (0x01 << 15);
capture_value[count_queen_black][0] = (0x02 << 24) + (0x01 << 15);
}

Houdini like RobboLito then initializes the board arrays/pile_initialization() (stack.c) and pawn_initialization() (p_value.c).

Houdini's value/material initialization:

Code: Select all
int cdecl sub_12A8340()
{
signed int v0; eax@1
int v1; ebp@3
int v2; eax@3
int v3; ebx@3
int v4; ecx@3
int v5; eax@3
int v6; ecx@3
int v7; edi@3
int v8; ecx@3
int v9; ecx@3
int v10; ecx@3
int v11; eax@3
int v12; esi@3
int v13; ST28_4@3
int v14; esi@3
int16 v15; dx@3
int16 v16; dh@1@3
int v17; ecx@3
int v18; eax@3
int64 v19; qax@4
int v20; eax@4
int64 v21; qax@6
int64 v22; qax@7
int v23; eax@12
int result; eax@12
int v25; [sp-38h] [bp-90h]@10
int v26; [sp-34h] [bp-8Ch]@10
int v27; [sp-30h] [bp-88h]@10
int v28; [sp-2Ch] [bp-84h]@10
int v29; [sp-28h] [bp-80h]@10
int v30; [sp-24h] [bp-7Ch]@10
int v31; [sp-20h] [bp-78h]@10
int v32; [sp-1Ch] [bp-74h]@10
int v33; [sp-18h] [bp-70h]@10
int v34; [sp-14h] [bp-6Ch]@10
int v35; [sp-10h] [bp-68h]@10
int v36; [sp-Ch] [bp-64h]@10
int v37; [sp-8h] [bp-60h]@10
int v38; [sp-4h] [bp-5Ch]@10
int v39; [sp+10h] [bp-48h]@3
int v40; [sp+14h] [bp-44h]@3
int v41; [sp+18h] [bp-40h]@3
int v42; [sp+1Ch] [bp-3Ch]@3
int v43; [sp+20h] [bp-38h]@3
int v44; [sp+20h] [bp-38h]@4
int v45; [sp+24h] [bp-34h]@3
int v46; [sp+28h] [bp-30h]@3
int v47; [sp+2Ch] [bp-2Ch]@3
int v48; [sp+30h] [bp-28h]@3
int v49; [sp+34h] [bp-24h]@3
int v50; [sp+38h] [bp-20h]@3
signed int v51; [sp+3Ch] [bp-1Ch]@1
signed int v52; [sp+40h] [bp-18h]@1
int v53; [sp+50h] [bp-8h]@3

v0 = 0;
v51 = 0;
v52 = &word_14414FC;
while ( 1 )
{
v1 = v0 % 2;
v2 = v0 / 2;
v3 = v2 % 2;
v4 = v2 / 2;
v5 = v2 / 2 / 3;
v41 = v4 - 3 * v5;
v6 = v5;
v5 /= 3;
v39 = v6 - 3 * v5;
v7 = v5 % 2;
v5 /= 2;
v8 = v5 % 2;
v5 /= 2;
v49 = v8;
v9 = v5 % 2;
v5 /= 2;
v46 = v9;
v45 = v5 % 2;
v10 = v5 / 2;
v11 = v5 / 2 / 3;
v42 = v10 - 3 * v11;
v40 = v11 % 3;
v12 = v11 / 3 / 9;
v47 = v46 + v45;
v48 = v12 % 9;
v13 = v12 % 9;
v14 = v7 + v49;
v50 = v11 / 3 % 9;
v53 = sub_12A8150(v50, v42, v7 + v49, v41, v1, v13, v11 % 3, v46 + v45, v39, v3);
v17 = v42 + v40 + v7 + v49 + v41 + v39 + 2 * (v3 + v1) + v46 + v45 + 2 * (v41 + v39 + 2 * (v3 + v1));
v43 = (v53 < 0) + SHIWORD(v53);
v18 = v43 < 0;
if ( v17 > 8 )
{
if ( v17 > 24 )
{
v22 = v53 * (v17 - 24) + v43 * (32 - v17);
v20 = ((BYTE4(v22) & 7) + v22) >> 3;
}
else
{
v21 = v43 * (v17 - 8) + (v18 + v15) * (24 - v17);
v20 = ((BYTE4(v21) & 0xF) + v21) >> 4;
}
v44 = v20;
}
else
{
v19 = v17 * (v18 + v15) + (8 - v17) * ((v18 + v15 < 0) + v16);
v20 = ((BYTE4(v19) & 7) + v19) >> 3;
v44 = v20;
}
if ( v20 <= 0 )
{
v38 = v1;
v37 = v41;
v36 = v49;
v35 = v7;
v34 = v7 + v49;
v33 = v42;
v32 = v50;
v31 = v3;
v30 = v39;
v29 = v45;
v28 = v46;
v27 = v46 + v45;
v26 = v40;
v25 = v48;
}
else
{
v38 = v3;
v37 = v39;
v36 = v45;
v35 = v46;
v34 = v46 + v45;
v33 = v40;
v32 = v48;
v31 = v1;
v30 = v41;
v29 = v49;
v28 = v7;
v27 = v7 + v49;
v26 = v42;
v25 = v50;
}
v23 = sub_12A7B30(v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38);
*(v52 - 4) = (((1717986919i64 * v44 * v23) >> 32) >>
2) + (((1717986919i64 * v44 * v23) >> 32) >> 31);
*(v52 - 2) = sub_12A79E0(v50, v42, v14, v7, v49, v41, v1, v40, v47, v46, v45, v39, v3);
*v52 = 0;
result = sub_12A7640(v52, v50, v42, v14, v7, v49, v41, v1, v48, v40, v47, v46, v45, v39, v3);
++v51;
*(v52 - 1) = result;
v52 += 6;
if ( v52 >= dword_16A867C )
break;
v0 = v51;
}
return result;
}

RobboLito's initialization_value()/Material_calculation( int c) (values.c):

Code: Select all
static void Material_calculation( int c )
{
int white_queen, black_queen, white_rook, black_rook, white_clear, black_clear, white_dark, black_dark,
white_knight, black_knight, white_pawn, black_pawn, n, value, white_bishop, black_bishop;
int ca, white_load, black_load, phase, va1, va2, va3, va4;
uint64 va;
n = c;
white_queen = n % 2;
n /= 2;
black_queen = n % 2;
n /= 2;
white_rook = n % 3;
n /= 3;
black_rook = n % 3;
n /= 3;
white_clear = n % 2;
n /= 2;
white_dark = n % 2;
n /= 2;
black_clear = n % 2;
n /= 2;
black_dark = n % 2;
n /= 2;
white_knight = n % 3;
n /= 3;
black_knight = n % 3;
n /= 3;
white_pawn = n % 9;
n /= 9;
black_pawn = n % 9;
white_bishop = white_clear + white_dark;
black_bishop = black_clear + black_dark;
va =
value_value(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen,
black_pawn, black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
phase =
PHASE_MINOR * (white_knight + white_bishop + black_knight + black_bishop)
+ PHASE_ROOK * (white_rook + black_rook) + PHASE_QUEEN * (white_queen + black_queen);
va1 = va & 0xffff;
va2 = ((va >> 16) & 0xffff) + (va1 > 0x8000);
va1 = (sint16)va1;
va3 = ((va >> 32) & 0xffff) + (va2 > 0x8000);
va2 = (sint16)va2;
va4 = ((va >> 48) & 0xffff) + (va3 > 0x8000);
va3 = (sint16)va3;
va4 = (sint16)va4;

if( phase < 8 )
{
va4 *= 8 - phase;
va3 *= phase;
va = va3 + va4;
value = ((int)va) / 8;
}
else if( phase < 24 )
{
va3 *= 24 - phase;
va2 *= phase - 8;
va = va2 + va3;
value = ((int)va) / 16;
}
else
{
va2 *= 32 - phase;
va1 *= phase - 24;
va = va1 + va2;
value = ((int)va) / 8;
}
white_load =
load_white(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen, black_pawn,
black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
black_load =
load_black(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen, black_pawn,
black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);

if( value > 0 )
ca = white_load;
else
ca = black_load;
value *= ca;
value /= 10;
MATERIAL[c].value = value;
MATERIAL[c].sign =
sengo_initialization(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen,
black_pawn, black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
MATERIAL[c].flags =
flags_initialization(white_pawn, white_knight, white_bishop, white_clear, white_dark, white_rook, white_queen,
black_pawn, black_knight, black_bishop, black_clear, black_dark, black_rook, black_queen);
}

There's probably a good answer for these:

Houdini:

Code: Select all
int cdecl sub_12A74B0(char a1)
{
int result; eax@1
void *v2; edx@2
int v3; edi@3

memset(byte_1405380, 0, 0x40u);
memset(&unk_14074F8, 0, 0x3A000u);
dword_1405388 = 16843009;
unk_140538C = 16843009;
dword_14053B0 = 151587081;
dword_14053B4 = 151587081;
byte_1405387 = 6;
byte_1405380[0] = 6;
byte_14053BF = 14;
byte_14053B8 = 14;
dword_14054F0 = &unk_14074F8;
byte_14054EA = 1;
word_1407511 = 15;
byte_14075DB = 0;
word_1405383 = 775;
byte_1405386 = 2;
byte_1405381 = 2;
byte_1405382 = 5;
byte_1405385 = 4;
unk_14053B9 = 185535498;
word_14053BD = 2573;
dword_1304AB0 = 1000;
dword_1304ABC = 0;
byte_1304AAC = 1;
dword_14054EC = 0;
result = sub_12A65A0();
if ( a1 )
{
memset(Memory, 0, 16 * dword_12BCFA0);
memset(&unk_1304AC0, 0, 0x100000u);
_mm_storel_pd(&qword_12C40C0, 0);
memcpy(&unk_12C40C8, &qword_12C40C0, 0x3FFF8u);
dword_13040CC = 0;
memset32(word_177B368, 134219776, 0x200u);
v2 = word_177C270;
do
{
result = 0;
memset(v2, 0, 0x1FFCu);
v3 = (v2 + 8188);
v2 = v2 + 8192;
*v3 = 0;
}
while ( v2 < dword_179C270 );
}
return result;
}

RobboLito:

Code: Select all
int cdecl sub_420230()
{
int result; eax@1

memset(&byte_6913C0, 0, 0x40u);
memset(&unk_62BBC0, 0, 0x8000u);
dword_6913C8 = 16843009;
unk_6913CC = 16843009;
dword_6913F0 = 151587081;
dword_6913F4 = 151587081;
byte_6913C7 = 6;
byte_6913C0 = 6;
byte_6913FF = 14;
byte_6913F8 = 14;
dword_68EF00 = (int)&unk_62BBC0;
byte_6914A0 = 1;
byte_62BBDC = 15;
word_62BBDD = 0;
word_6913C3 = 775;
byte_6913C6 = 2;
byte_6913C1 = 2;
byte_6913C2 = 5;
byte_6913C5 = 4;
unk_6913F9 = 185535498;
word_6913FD = 2573;
dword_47B5E4 = 1000;
dword_47B5E8 = 0;
byte_48BAA0 = 1;
dword_48E100 = 0;
sub_41EDD0();
memset(Dst, 0, 16 * dword_42E018);
memset(&unk_6914C0, 0, 0x100000u);
dword_43AEA0 = 0;
dword_43AEA4 = 0;
memcpy(&unk_43AEA8, &dword_43AEA0, 0x3FFF8u);
memset32(&word_62B1C0, 134219776, 0x200u);
result = 0;
memset(&word_64BE60, 0, 0x1FFE0u);
dword_6913A0 = 0;
unk_6913A4 = 0;
return result;
}

Perhaps there's an explanation for this exact match?

[You must be registered and logged in to see this image.]

[You must be registered and logged in to see this link.]

re: re: continued
[You must be registered and logged in to see this link.]
15 minutes ago

Perhaps there's an explanation for this exact match?

Houdini

Code: Select all
int thiscall sub_12A6470(void *this)
{
char *v1; eax@1
char v2; cl@2
char *v4; [sp-2h] [bp-1000Ch]@1
char v5; [sp+2h] [bp-10008h]@1
_BYTE v6[3]; [sp+3h] [bp-10007h]@3
unsigned int v7; [sp+10006h] [bp-4h]@1

v7 = &v5 ^ security_cookie;
v4 = sub_12A87BF(this);
fgets(&v5, 65536, v4);
v1 = &v5;
do
v2 = *v1++;
while ( v2 );
LOBYTE((&v4)[v1 - v6 + 3]) = 0;
v4 = &v5;
return sub_12A6020(v4);
}

RobboLito:

Code: Select all
int thiscall sub_424130(void *this)
{
char *v1; eax@1
char v2; cl@2
char *v4; [sp-2h] [bp-1000Ch]@1
char v5; [sp+2h] [bp-10008h]@1
_BYTE v6[3]; [sp+3h] [bp-10007h]@3
unsigned int v7; [sp+10006h] [bp-4h]@1

v7 = (unsigned int)&v5 ^ security_cookie;
v4 = (char *)sub_42714D(this);
fgets(&v5, 65536, (FILE *)v4);
v1 = &v5;
do
v2 = *v1++;
while ( v2 );
LOBYTE((&v4)[v1 - v6 + 3]) = 0;
v4 = &v5;
return sub_423B90(v4);
}

input_console() (uci.c):

Code: Select all
void input_console()
{
char string[65536];
fgets(string, 65536, stdin);
string[strlen(string) - 1] = 0;
parse(string);
}

Is there really much point to go through the eval and search? In any
case, this was probably a huge waste of time as am sure most reasonable
people recognize that Houdini base code is RobboLito.

[You must be registered and logged in to see this image.]

[You must be registered and logged in to see this link.]

Subject: Re: Houdini EXPOSED Tue Oct 11, 2011 7:03 pm

i dont' want to be in the houdini side but in his web site he say the following :

Without many ideas and techniques from the open source chess engines Ippolit and Stockfish, Houdini would not nearly be as strong as it is now.

now to copy the code ...

Subject: Re: Houdini EXPOSED Tue Oct 11, 2011 7:11 pm

theropodes wrote:: i dont' want to be in the houdini side but in his web site he say the following :

Without many ideas and techniques from the open source chess engines Ippolit and Stockfish, Houdini would not nearly be as strong as it is now.

now to copy the code ...

he has repeatedly denied even looking at Ippoli source codes robbolito is ippolit and hes directly copied parts of the codes

_________________
"No one is never ever truly gone as long as you remember them "

Subject: Re: Houdini EXPOSED Tue Oct 11, 2011 7:38 pm

rybka & houdini same logic (no honesty), same target (commercial)
fuck capitalist and happy opensource system and community

Subject: Re: Houdini EXPOSED Tue Oct 11, 2011 8:50 pm

Serious guys,

did anyone ever doubted ?

Subject: Re: Houdini EXPOSED Wed Oct 12, 2011 7:06 am

Houdini added to "Contoversial" list by CCRL

[You must be registered and logged in to see this link.]

[You must be registered and logged in to see this link.]

[You must be registered and logged in to see this link.]
just now

Seems Houdarts becoming an embarrassment to his backers just as the cloner he emulated has

[You must be registered and logged in to see this image.]

Subject: Re: Houdini EXPOSED Wed Oct 12, 2011 8:53 am

[You must be registered and logged in to see this link.]

re: re: continued
[You must be registered and logged in to see this link.]
just now

Message
Norman Schmidt

Joined: 29 May 2008
Posts: 1031

PostPost subject: Re: Houdini with 1:1 Robbolito-code? Posted: Wed Oct 12, 2011

The Robbolito versions that are being used in the comparison above (0.085g3 and 0.09) were released under GPL...

These have been meticulously translated to common English programming terms.
The are greatly modified, improved, stronger, and bug-free versions
(with lots of original coding and ideas) of the very original
ippolit.wikispaces.com Robbolito releases.

They were released by myself and Sentinel under GPL license from [You must be registered and logged in to see this link.]

- [You must be registered and logged in to see this link.] just now

best game keeper's are former poachers +1 to kranium

[You must be registered and logged in to see this image.]

Subject: Re: Houdini EXPOSED Wed Oct 12, 2011 12:59 pm

[You must be registered and logged in to see this link.]

re: re: continued
[You must be registered and logged in to see this link.]
13 minutes ago

There's probably a good answer for these:

by [You must be registered and logged in to see this link.] » Wed Oct 12, 2011 1:15 pm

There's probably a good answer for these as well

RobboLito's game_new( bool total ) (utils.c)
Code: [You must be registered and logged in to see this link.]void game_new( bool total )
{
int i;

for ( i = A1; i <= H8; i++ )
QU[i] = 0;
memset(dynamic_initial, 0, 256 * sizeof(type_dynamic));
DYNAMIC = dynamic_initial;
POSITION.white_en_move = TRUE;
DYNAMIC->castle = 0x0f;
DYNAMIC->en_passant = 0;
DYNAMIC->move50 = 0;
~~~~
The decompiled Houdini and accompanied RobboLito version is on the [You must be registered and logged in to see this link.].
To be clear, this is not a copy/paste situation but rather code
modification. The above function is where the bitboard initialization is
called.

Houdini bitboard initialization sub_12A65A0():
Code: [You must be registered and logged in to see this link.]int __cdecl sub_12A65A0()
{
signed int v0; // edx@1
int v1; // ecx@2
int v2; // eax@3
int v3; // esi@5
int v4; // eax@6
int v5; // eax@6
int v6; // ebp@12
int v7; // ebx@12
__int64 v8; // qdi@12
int v9; // ecx@23
int v10; // eax@24

~~~

RobboLIto:
Code: [You must be registered and logged in to see this link.]int __cdecl sub_424270()
{
int v0; // esi@1
signed int v1; // edi@1
int v2; // ebx@2
int v3; // eax@3
int v4; // ebx@7
int v5; // eax@8
signed __int64 v6; // qax@11
int v7; // ebx@12
int v8; // eax@13
signed __int64 v9; // qax@16
int v10; // ebx@17

~~~~

RobboLito's bitboard_initialization() (utils.c):
Code: [You must be registered and logged in to see this link.]void bitboard_initialization()
{
int i, b, piece;
uint64 O;
border_legitimate = FALSE;

for ( i = 0; i < 16; i++ )
POSITION.bitboard[i] = 0;
DYNAMIC->Zobrist = DYNAMIC->ZobristPawn = 0;
DYNAMIC->material_ = 0;
DYNAMIC->statik = 0;

for ( i = A1; i <= H8; i++ )
{
if( (piece = QU[i]) )
{
DYNAMIC->statik += static_value[piece][i];
DYNAMIC->Zobrist ^= ZOBRIST[piece][i];

if( piece == count_pawn_white || piece == count_pawn_black )
DYNAMIC->ZobristPawn ^= ZOBRIST[piece][i];
DYNAMIC->material_ += value_material_[piece];
bitFIXED(i, POSITION.bitboard[QU[i]]);
}
}
bitboard_occupied_white =
bitboard_white_king | bitboard_white_queen | bitboard_white_rook | bitboard_white_bishop | bitboard_white_knight
| bitboard_white_pawn;
bitboard_occupied_black =
bitboard_black_king | bitboard_black_queen | bitboard_black_rook | bitboard_black_bishop | bitboard_black_knight
| bitboard_black_pawn;
POSITION.occupied_black_white = bitboard_occupied_white | bitboard_occupied_black;
POSITION.occupied_left90 = POSITION.occupied_left45 = POSITION.occupied_straight45 = 0;
O = POSITION.occupied_black_white;

if( POPCNT(bitboard_white_queen) > 1 || POPCNT(bitboard_black_queen) > 1 || POPCNT(bitboard_white_rook) > 2
|| POPCNT(bitboard_black_rook) > 2 || POPCNT(bitboard_white_clear) > 1 || POPCNT(bitboard_black_clear) > 1
|| POPCNT(bitboard_white_knight) > 2 || POPCNT(bitboard_black_knight) > 2 || POPCNT(bitboard_white_dark) > 1
|| POPCNT(bitboard_black_dark) > 1 )
DYNAMIC->material_ |= 0x80000000;

if( POPCNT(bitboard_white_king) != 1 )
ERROR_pos("king white != 1");

if( POPCNT(bitboard_black_king) != 1 )
ERROR_pos("king black != 1");

if( POPCNT(bitboard_white_queen) > 9 )
ERROR_pos("queen white > 9");

if( POPCNT(bitboard_black_queen) > 9 )
ERROR_pos("queen black > 9");

if( POPCNT(bitboard_white_rook) > 10 )
ERROR_pos("rook white > 10");

if( POPCNT(bitboard_black_rook) > 10 )
ERROR_pos("rook black > 10");

if( POPCNT(bitboard_white_clear) > 9 )
ERROR_pos("chiaro white > 9");

if( POPCNT(bitboard_black_clear) > 9 )
ERROR_pos("chiaro black > 9");

if( POPCNT(bitboard_white_dark) > 9 )
ERROR_pos("dark white > 9");

if( POPCNT(bitboard_black_dark) > 9 )
ERROR_pos("dark black > 9");

if( POPCNT(bitboard_white_clear | bitboard_white_dark) > 10 )
ERROR_pos("bishop white > 10");

if( POPCNT(bitboard_black_clear | bitboard_black_dark) > 10 )
ERROR_pos("bishop black > 10");

if( POPCNT(bitboard_white_knight) > 10 )
ERROR_pos("knight white > 10");

if( POPCNT(bitboard_black_knight) > 10 )
ERROR_pos("knight black > 10");

if( POPCNT(bitboard_white_pawn) > 8 )
ERROR_pos("pawn white > 8");

if( POPCNT(bitboard_black_pawn) > 8 )
ERROR_pos("pawn black > 8");

if( POPCNT(bitboard_occupied_white) > 16 )
ERROR_pos("piece white > 16");

if( POPCNT(bitboard_occupied_black) > 16 )
ERROR_pos("piece black > 16");

if( (bitboard_white_pawn | bitboard_black_pawn) & (RANK1 | RANK8) )
ERROR_pos("pawn rank one or eight");

while( O )
{
b = BSF(O);
bit_FREE(b, O);
bitFIXED(left90[b], POSITION.occupied_left90);
bitFIXED(left45[b], POSITION.occupied_left45);
bitFIXED(straight45[b], POSITION.occupied_straight45);
}
POSITION.white_king_square = BSF(bitboard_white_king);
POSITION.black_king_square = BSF(bitboard_black_king);

if( (castling_white_oo && (POSITION.white_king_square != E1 || !(bitboard_white_rook &square_fixed[H1])))
|| (castling_white_ooo && (POSITION.white_king_square != E1 || !(bitboard_white_rook &square_fixed[A1])))
|| (castling_black_oo && (POSITION.black_king_square != E8 || !(bitboard_black_rook &square_fixed[H8])))

|| (castling_black_ooo && (POSITION.black_king_square
!= E8 || !(bitboard_black_rook &square_fixed[A8]))) )
ERROR_pos("castle illegale");
DYNAMIC->Zobrist ^= zobrist_oo[DYNAMIC->castle];

if( DYNAMIC->en_passant )
DYNAMIC->Zobrist ^= zobrist_ep[DYNAMIC->en_passant & 7];
DYNAMIC->ZobristPawn ^=
zobrist_oo[DYNAMIC->castle] ^ PINCH ^ ZOBRIST[count_king_white][POSITION.white_king_square]
^ ZOBRIST[count_king_black][POSITION.black_king_square];

if( POSITION.white_en_move )
DYNAMIC->Zobrist ^= zobrist_move_white;
call_value_full(0);

if( POSITION.white_en_move && DYNAMIC->attak_white & bitboard_black_king )
ERROR_pos("white capture re");

if( !POSITION.white_en_move && DYNAMIC->attak_black & bitboard_white_king )
ERROR_pos("black catture re");
border_legitimate = TRUE;
}
Houdini has modified the output but it's essentially the same code.

[You must be registered and logged in to see this link.]

Subject: Re: Houdini EXPOSED Thu Oct 13, 2011 4:55 am

[You must be registered and logged in to see this link.]

re: Programers speak up , Houdart cheap plagiarizing liar or genius
[You must be registered and logged in to see this link.]
Today 1:26 am

Richard Vida ( Critter )
Speaking of Houdini on Talk Chess forum

"It is derived from Ippolit."

[You must be registered and logged in to see this link.]

» Houdini 1.5a 32 bit codes exposed >> get it here
» Strelka / Houdini search secrets exposed
» Houdini 1.03a is the last release of the "Houdini 1.0" family
» Houdini FREE pro vs Houdini 1.5a from another forum :)
» Pioneer chess tournement results exsposed (EXPOSED as ....)