10 #elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
12 static int first_one00( int pcs );
13 static int last_one00( int pcs );
17 static void ini_check_table( void );
18 static bitboard_t bb_set_mask( int isquare );
19 static int load_fv( void );
20 static void set_attacks( int irank, int ifilea, bitboard_t *pbb );
21 static void ini_is_same( void );
22 static void ini_tables( void );
23 static void ini_attack_tables( void );
24 static void ini_random_table( void );
34 pf = file_open( str_fv, "rb" );
35 if ( pf == NULL ) { return -2; }
37 size = nsquare * pos_n;
38 if ( fread( pc_on_sq, sizeof(short), size, pf ) != size )
40 str_error = str_io_error;
44 size = nsquare * nsquare * kkp_end;
45 if ( fread( kkp, sizeof(short), size, pf ) != size )
47 str_error = str_io_error;
51 iret = file_close( pf );
52 if ( iret < 0 ) { return iret; }
58 unsigned int a[X1-X0+1];
61 for ( i = 0; i < X1-X0+1; i++ ) { a[i] = 0; }
63 for ( i = 0; i < n; i++ )
66 if ( iv < X0 ) { iv = X0; }
67 else if ( iv > X1 ) { iv = X1; }
71 pf = file_open( "dist.dat", "w" );
72 if ( pf == NULL ) { return -2; }
74 for ( i = X0; i <= X1; i++ ) { fprintf( pf, "%d %d\n", i, a[i-X0] ); }
76 iret = file_close( pf );
77 if ( iret < 0 ) { return iret; }
93 pf = file_open( str_fv, "wb" );
94 if ( pf == NULL ) { return -2; }
96 size = nsquare * pos_n;
97 for ( i = 0; i < size; i++ ) { pc_on_sq[0][i] = 0; }
98 if ( fwrite( pc_on_sq, sizeof(short), size, pf ) != size )
100 str_error = str_io_error;
104 size = nsquare * nsquare * kkp_end;
105 for ( i = 0; i < size; i++ ) { kkp[0][0][i] = 0; }
106 if ( fwrite( kkp, sizeof(short), size, pf ) != size )
108 str_error = str_io_error;
112 return file_close( pf );
117 ini( tree_t * restrict ptree )
121 /*if ( ini_fv() < 0 ) { return -1; }*/
122 if ( load_fv() < 0 ) { return -1; }
124 for ( i = 0; i < 31; i++ ) { p_value[i] = 0; }
125 for ( i = 0; i < 31; i++ ) { p_value_ex[i] = 0; }
126 for ( i = 0; i < 15; i++ ) { benefit2promo[i] = 0; }
127 p_value[15+pawn] = DPawn;
128 p_value[15+lance] = DLance;
129 p_value[15+knight] = DKnight;
130 p_value[15+silver] = DSilver;
131 p_value[15+gold] = DGold;
132 p_value[15+bishop] = DBishop;
133 p_value[15+rook] = DRook;
134 p_value[15+king] = DKing;
135 p_value[15+pro_pawn] = DProPawn;
136 p_value[15+pro_lance] = DProLance;
137 p_value[15+pro_knight] = DProKnight;
138 p_value[15+pro_silver] = DProSilver;
139 p_value[15+horse] = DHorse;
140 p_value[15+dragon] = DDragon;
143 str_buffer_cmdline[0] = '\0';
144 ptrans_table_orig = NULL;
145 record_game.pf = NULL;
146 node_per_second = TIME_CHECK_MIN_NODE;
147 node_limit = UINT64_MAX;
148 time_response = TIME_RESPONSE;
151 sec_limit_depth = UINT_MAX;
152 depth_limit = PLY_MAX;
153 log2_ntrans_table = 20;
163 tlp_atree_work[0].tlp_id = 0;
164 tlp_atree_work[0].tlp_abort = 0;
165 tlp_atree_work[0].tlp_used = 1;
166 tlp_atree_work[0].tlp_slot = 0;
167 tlp_atree_work[0].tlp_nsibling = 0;
168 if ( lock_init( &tlp_atree_work[0].tlp_lock ) < 0 ) { return -1; }
169 if ( lock_init( &tlp_lock ) < 0 ) { return -1; }
170 for ( i = 0; i < tlp_max; i++ )
172 tlp_atree_work->tlp_ptrees_sibling[i] = NULL;
174 for ( i = 1; i < TLP_NUM_WORK; i++ )
176 tlp_atree_work[i].tlp_slot = (unsigned short)i;
177 tlp_atree_work[i].tlp_used = 0;
178 if ( lock_init( &tlp_atree_work[i].tlp_lock ) < 0 ) { return -1; }
182 if ( pthread_attr_init( &pthread_attr )
183 || pthread_attr_setdetachstate( &pthread_attr,
184 PTHREAD_CREATE_DETACHED ) )
186 str_error = "pthread_attr_init() failed.";
193 sckt_csa = SCKT_NULL;
198 for ( i = 1; i < MNJ_MASK + 1; i++ ) { mnj_tbl[i] = 0; }
199 sckt_mnj = SCKT_NULL;
206 # if defined(DEKUNOBOU)
210 clk_tck = (clock_t)sysconf(_SC_CLK_TCK);
213 #if ! defined(NO_LOGGING)
217 #if defined(_MSC_VER)
218 #elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
220 for ( i = 0; i < 0x200; i++ )
222 aifirst_one[i] = (unsigned char)first_one00(i);
223 ailast_one[i] = (unsigned char)last_one00(i);
227 for ( i = 0; i < HASH_REG_HIST_LEN; i++ )
229 history_book_learn[i].move_responsible = 0;
230 history_book_learn[i].move_probed = 0;
231 history_book_learn[i].move_played = 0;
241 set_derivative_param();
243 if ( ini_game( ptree, &min_posi_no_handicap, flag_history, NULL, NULL ) < 0 )
248 OutCsaShogi( "%s\n", str_myname );
249 Out( "%s\n", str_myname );
251 if ( ini_trans_table() < 0 ) { return -1; }
253 if ( book_on() < 0 ) { out_warning( "%s", str_error );}
254 else { Out( "%s found\n", str_book );}
256 if ( hash_learn_on() < 0 ) { out_warning( "%s", str_error );}
257 else { Out( "%s found\n", str_hash );}
259 if ( get_elapsed( &time_turn_start ) < 0 ) { return -1; }
261 ini_rand( time_turn_start );
262 Out( "rand seed = %x\n", time_turn_start );
264 resign_threshold = RESIGN_THRESHOLD;
268 mpv_width = 2 * MT_CAP_PAWN;
282 memory_free( (void *)ptrans_table_orig );
286 while ( tlp_num ) { tlp_yield(); }
287 if ( lock_free( &tlp_atree_work[0].tlp_lock ) < 0 ) { return -1; }
288 if ( lock_free( &tlp_lock ) < 0 ) { return -1; }
289 for ( i = 1; i < TLP_NUM_WORK; i++ )
291 if ( lock_free( &tlp_atree_work[i].tlp_lock ) < 0 ) { return -1; }
295 if ( pthread_attr_destroy( &pthread_attr ) )
297 str_error = "pthread_attr_destroy() failed.";
303 if ( book_off() < 0 ) { return -1; }
304 if ( record_close( &record_game ) < 0 ) { return -1; }
305 #if ! defined(NO_LOGGING)
306 if ( file_close( pf_log ) < 0 ) { return -1; }
314 set_derivative_param( void )
316 p_value_ex[15+pawn] = p_value[15+pawn] + p_value[15+pawn];
317 p_value_ex[15+lance] = p_value[15+lance] + p_value[15+lance];
318 p_value_ex[15+knight] = p_value[15+knight] + p_value[15+knight];
319 p_value_ex[15+silver] = p_value[15+silver] + p_value[15+silver];
320 p_value_ex[15+gold] = p_value[15+gold] + p_value[15+gold];
321 p_value_ex[15+bishop] = p_value[15+bishop] + p_value[15+bishop];
322 p_value_ex[15+rook] = p_value[15+rook] + p_value[15+rook];
323 p_value_ex[15+king] = p_value[15+king] + p_value[15+king];
324 p_value_ex[15+pro_pawn] = p_value[15+pro_pawn] + p_value[15+pawn];
325 p_value_ex[15+pro_lance] = p_value[15+pro_lance] + p_value[15+lance];
326 p_value_ex[15+pro_knight] = p_value[15+pro_knight] + p_value[15+knight];
327 p_value_ex[15+pro_silver] = p_value[15+pro_silver] + p_value[15+silver];
328 p_value_ex[15+horse] = p_value[15+horse] + p_value[15+bishop];
329 p_value_ex[15+dragon] = p_value[15+dragon] + p_value[15+rook];
331 benefit2promo[7+pawn] = p_value[15+pro_pawn] - p_value[15+pawn];
332 benefit2promo[7+lance] = p_value[15+pro_lance] - p_value[15+lance];
333 benefit2promo[7+knight] = p_value[15+pro_knight] - p_value[15+knight];
334 benefit2promo[7+silver] = p_value[15+pro_silver] - p_value[15+silver];
335 benefit2promo[7+bishop] = p_value[15+horse] - p_value[15+bishop];
336 benefit2promo[7+rook] = p_value[15+dragon] - p_value[15+rook];
338 p_value[15-pawn] = p_value[15+pawn];
339 p_value[15-lance] = p_value[15+lance];
340 p_value[15-knight] = p_value[15+knight];
341 p_value[15-silver] = p_value[15+silver];
342 p_value[15-gold] = p_value[15+gold];
343 p_value[15-bishop] = p_value[15+bishop];
344 p_value[15-rook] = p_value[15+rook];
345 p_value[15-king] = p_value[15+king];
346 p_value[15-pro_pawn] = p_value[15+pro_pawn];
347 p_value[15-pro_lance] = p_value[15+pro_lance];
348 p_value[15-pro_knight] = p_value[15+pro_knight];
349 p_value[15-pro_silver] = p_value[15+pro_silver];
350 p_value[15-horse] = p_value[15+horse];
351 p_value[15-dragon] = p_value[15+dragon];
353 p_value_ex[15-pawn] = p_value_ex[15+pawn];
354 p_value_ex[15-lance] = p_value_ex[15+lance];
355 p_value_ex[15-knight] = p_value_ex[15+knight];
356 p_value_ex[15-silver] = p_value_ex[15+silver];
357 p_value_ex[15-gold] = p_value_ex[15+gold];
358 p_value_ex[15-bishop] = p_value_ex[15+bishop];
359 p_value_ex[15-rook] = p_value_ex[15+rook];
360 p_value_ex[15-king] = p_value_ex[15+king];
361 p_value_ex[15-pro_pawn] = p_value_ex[15+pro_pawn];
362 p_value_ex[15-pro_lance] = p_value_ex[15+pro_lance];
363 p_value_ex[15-pro_knight] = p_value_ex[15+pro_knight];
364 p_value_ex[15-pro_silver] = p_value_ex[15+pro_silver];
365 p_value_ex[15-horse] = p_value_ex[15+horse];
366 p_value_ex[15-dragon] = p_value_ex[15+dragon];
368 benefit2promo[7-pawn] = benefit2promo[7+pawn];
369 benefit2promo[7-lance] = benefit2promo[7+lance];
370 benefit2promo[7-knight] = benefit2promo[7+knight];
371 benefit2promo[7-silver] = benefit2promo[7+silver];
372 benefit2promo[7-bishop] = benefit2promo[7+bishop];
373 benefit2promo[7-rook] = benefit2promo[7+rook];
382 for ( i = 0; i < 16; i++ ) { p[i] = 0; }
399 for ( i = 0; i < 16; i++ )
400 for ( j = 0; j < 16; j++ )
402 if ( p[i] < p[j]-1 ) { is_same[i][j] = 2U; }
403 else if ( p[i] > p[j]+1 ) { is_same[i][j] = 1U; }
404 else { is_same[i][j] = 0U; }
412 const unsigned char aini_rl90[] = { A1, A2, A3, A4, A5, A6, A7, A8, A9,
413 B1, B2, B3, B4, B5, B6, B7, B8, B9,
414 C1, C2, C3, C4, C5, C6, C7, C8, C9,
415 D1, D2, D3, D4, D5, D6, D7, D8, D9,
416 E1, E2, E3, E4, E5, E6, E7, E8, E9,
417 F1, F2, F3, F4, F5, F6, F7, F8, F9,
418 G1, G2, G3, G4, G5, G6, G7, G8, G9,
419 H1, H2, H3, H4, H5, H6, H7, H8, H9,
420 I1, I2, I3, I4, I5, I6, I7, I8, I9 };
422 const unsigned char aini_rl45[] = { A9, B1, C2, D3, E4, F5, G6, H7, I8,
423 A8, B9, C1, D2, E3, F4, G5, H6, I7,
424 A7, B8, C9, D1, E2, F3, G4, H5, I6,
425 A6, B7, C8, D9, E1, F2, G3, H4, I5,
426 A5, B6, C7, D8, E9, F1, G2, H3, I4,
427 A4, B5, C6, D7, E8, F9, G1, H2, I3,
428 A3, B4, C5, D6, E7, F8, G9, H1, I2,
429 A2, B3, C4, D5, E6, F7, G8, H9, I1,
430 A1, B2, C3, D4, E5, F6, G7, H8, I9 };
432 const unsigned char aini_rr45[] = { I8, I7, I6, I5, I4, I3, I2, I1, I9,
433 H7, H6, H5, H4, H3, H2, H1, H9, H8,
434 G6, G5, G4, G3, G2, G1, G9, G8, G7,
435 F5, F4, F3, F2, F1, F9, F8, F7, F6,
436 E4, E3, E2, E1, E9, E8, E7, E6, E5,
437 D3, D2, D1, D9, D8, D7, D6, D5, D4,
438 C2, C1, C9, C8, C7, C6, C5, C4, C3,
439 B1, B9, B8, B7, B6, B5, B4, B3, B2,
440 A9, A8, A7, A6, A5, A4, A3, A2, A1 };
441 bitboard_t abb_plus1dir[ nsquare ];
442 bitboard_t abb_plus8dir[ nsquare ];
443 bitboard_t abb_plus9dir[ nsquare ];
444 bitboard_t abb_plus10dir[ nsquare ];
445 bitboard_t abb_minus1dir[ nsquare ];
446 bitboard_t abb_minus8dir[ nsquare ];
447 bitboard_t abb_minus9dir[ nsquare ];
448 bitboard_t abb_minus10dir[ nsquare ];
450 int isquare, i, ito, ifrom, irank, ifile;
451 int isquare_rl90, isquare_rl45, isquare_rr45;
453 for ( isquare = 0; isquare < nsquare; isquare++ )
455 isquare_rl90 = aini_rl90[isquare];
456 isquare_rl45 = aini_rl45[isquare];
457 isquare_rr45 = aini_rr45[isquare];
458 abb_mask[isquare] = bb_set_mask( isquare );
459 abb_mask_rl90[isquare] = bb_set_mask( isquare_rl90 );
460 abb_mask_rl45[isquare] = bb_set_mask( isquare_rl45 );
461 abb_mask_rr45[isquare] = bb_set_mask( isquare_rr45 );
464 for ( irank = 0; irank < nrank; irank++ )
465 for ( ifile = 0; ifile < nfile; ifile++ )
467 isquare = irank*nfile + ifile;
468 BBIni( abb_plus1dir[isquare] );
469 BBIni( abb_plus8dir[isquare] );
470 BBIni( abb_plus9dir[isquare] );
471 BBIni( abb_plus10dir[isquare] );
472 BBIni( abb_minus1dir[isquare] );
473 BBIni( abb_minus8dir[isquare] );
474 BBIni( abb_minus9dir[isquare] );
475 BBIni( abb_minus10dir[isquare] );
476 for ( i = 1; i < nfile; i++ )
478 set_attacks( irank, ifile+i, abb_plus1dir + isquare );
479 set_attacks( irank+i, ifile-i, abb_plus8dir + isquare );
480 set_attacks( irank+i, ifile, abb_plus9dir + isquare );
481 set_attacks( irank+i, ifile+i, abb_plus10dir + isquare );
482 set_attacks( irank, ifile-i, abb_minus1dir + isquare );
483 set_attacks( irank-i, ifile+i, abb_minus8dir + isquare );
484 set_attacks( irank-i, ifile, abb_minus9dir + isquare );
485 set_attacks( irank-i, ifile-i, abb_minus10dir + isquare );
490 for ( isquare = 0; isquare < nsquare; isquare++ )
492 BBOr( abb_plus_rays[isquare],
493 abb_plus1dir[isquare], abb_plus8dir[isquare] );
494 BBOr( abb_plus_rays[isquare],
495 abb_plus_rays[isquare], abb_plus9dir[isquare] );
496 BBOr( abb_plus_rays[isquare],
497 abb_plus_rays[isquare], abb_plus10dir[isquare] );
498 BBOr( abb_minus_rays[isquare],
499 abb_minus1dir[isquare], abb_minus8dir[isquare] );
500 BBOr( abb_minus_rays[isquare],
501 abb_minus_rays[isquare], abb_minus9dir[isquare] );
502 BBOr( abb_minus_rays[isquare],
503 abb_minus_rays[isquare], abb_minus10dir[isquare] );
507 for ( ifrom = 0; ifrom < nsquare; ifrom++ )
509 for ( ito = 0; ito < nsquare; ito++ )
511 adirec[ifrom][ito] = (unsigned char)direc_misc;
514 BBOr( bb, abb_plus1dir[ifrom], abb_minus1dir[ifrom] );
517 ito = FirstOne( bb );
518 adirec[ifrom][ito] = (unsigned char)direc_rank;
521 BBOr( bb, abb_plus8dir[ifrom], abb_minus8dir[ifrom] );
524 ito = FirstOne( bb );
525 adirec[ifrom][ito] = (unsigned char)direc_diag1;
528 BBOr( bb, abb_plus9dir[ifrom], abb_minus9dir[ifrom] );
531 ito = FirstOne( bb );
532 adirec[ifrom][ito] = (unsigned char)direc_file;
535 BBOr( bb, abb_plus10dir[ifrom], abb_minus10dir[ifrom] );
538 ito = FirstOne( bb );
539 adirec[ifrom][ito] = (unsigned char)direc_diag2;
544 for ( ifrom = 0; ifrom < nsquare; ifrom++ )
545 for ( ito = 0; ito < nsquare; ito++ )
547 BBIni( abb_obstacle[ifrom][ito] );
549 if ( ifrom-ito > 0 ) switch ( adirec[ifrom][ito] )
552 BBXor( abb_obstacle[ifrom][ito],
553 abb_minus1dir[ito+1], abb_minus1dir[ifrom] );
556 BBXor( abb_obstacle[ifrom][ito],
557 abb_minus9dir[ito+9], abb_minus9dir[ifrom] );
560 BBXor( abb_obstacle[ifrom][ito],
561 abb_minus8dir[ito+8], abb_minus8dir[ifrom] );
564 BBXor( abb_obstacle[ifrom][ito],
565 abb_minus10dir[ito+10], abb_minus10dir[ifrom] );
568 else switch ( adirec[ifrom][ito] )
571 BBXor( abb_obstacle[ifrom][ito],
572 abb_plus1dir[ito-1], abb_plus1dir[ifrom] );
575 BBXor( abb_obstacle[ifrom][ito],
576 abb_plus9dir[ito-9], abb_plus9dir[ifrom] );
579 BBXor( abb_obstacle[ifrom][ito],
580 abb_plus8dir[ito-8], abb_plus8dir[ifrom] );
583 BBXor( abb_obstacle[ifrom][ito],
584 abb_plus10dir[ito-10], abb_plus10dir[ifrom] );
592 ini_random_table( void )
596 for ( i = 0; i < nsquare; i++ )
598 b_pawn_rand[ i ] = rand64();
599 b_lance_rand[ i ] = rand64();
600 b_knight_rand[ i ] = rand64();
601 b_silver_rand[ i ] = rand64();
602 b_gold_rand[ i ] = rand64();
603 b_bishop_rand[ i ] = rand64();
604 b_rook_rand[ i ] = rand64();
605 b_king_rand[ i ] = rand64();
606 b_pro_pawn_rand[ i ] = rand64();
607 b_pro_lance_rand[ i ] = rand64();
608 b_pro_knight_rand[ i ] = rand64();
609 b_pro_silver_rand[ i ] = rand64();
610 b_horse_rand[ i ] = rand64();
611 b_dragon_rand[ i ] = rand64();
612 w_pawn_rand[ i ] = rand64();
613 w_lance_rand[ i ] = rand64();
614 w_knight_rand[ i ] = rand64();
615 w_silver_rand[ i ] = rand64();
616 w_gold_rand[ i ] = rand64();
617 w_bishop_rand[ i ] = rand64();
618 w_rook_rand[ i ] = rand64();
619 w_king_rand[ i ] = rand64();
620 w_pro_pawn_rand[ i ] = rand64();
621 w_pro_lance_rand[ i ] = rand64();
622 w_pro_knight_rand[ i ] = rand64();
623 w_pro_silver_rand[ i ] = rand64();
624 w_horse_rand[ i ] = rand64();
625 w_dragon_rand[ i ] = rand64();
628 for ( i = 0; i < npawn_max; i++ )
630 b_hand_pawn_rand[ i ] = rand64();
631 w_hand_pawn_rand[ i ] = rand64();
634 for ( i = 0; i < nlance_max; i++ )
636 b_hand_lance_rand[ i ] = rand64();
637 b_hand_knight_rand[ i ] = rand64();
638 b_hand_silver_rand[ i ] = rand64();
639 b_hand_gold_rand[ i ] = rand64();
640 w_hand_lance_rand[ i ] = rand64();
641 w_hand_knight_rand[ i ] = rand64();
642 w_hand_silver_rand[ i ] = rand64();
643 w_hand_gold_rand[ i ] = rand64();
646 for ( i = 0; i < nbishop_max; i++ )
648 b_hand_bishop_rand[ i ] = rand64();
649 b_hand_rook_rand[ i ] = rand64();
650 w_hand_bishop_rand[ i ] = rand64();
651 w_hand_rook_rand[ i ] = rand64();
657 ini_attack_tables( void )
659 int irank, ifile, pcs, i;
662 for ( irank = 0; irank < nrank; irank++ )
663 for ( ifile = 0; ifile < nfile; ifile++ )
666 set_attacks( irank-1, ifile-1, &bb );
667 set_attacks( irank-1, ifile+1, &bb );
668 set_attacks( irank+1, ifile-1, &bb );
669 set_attacks( irank+1, ifile+1, &bb );
670 set_attacks( irank-1, ifile, &bb );
671 abb_b_silver_attacks[ irank*nfile + ifile ] = bb;
674 set_attacks( irank-1, ifile-1, &bb );
675 set_attacks( irank-1, ifile+1, &bb );
676 set_attacks( irank+1, ifile-1, &bb );
677 set_attacks( irank+1, ifile+1, &bb );
678 set_attacks( irank+1, ifile, &bb );
679 abb_w_silver_attacks[ irank*nfile + ifile ] = bb;
682 set_attacks( irank-1, ifile-1, &bb );
683 set_attacks( irank-1, ifile+1, &bb );
684 set_attacks( irank-1, ifile, &bb );
685 set_attacks( irank+1, ifile, &bb );
686 set_attacks( irank, ifile-1, &bb );
687 set_attacks( irank, ifile+1, &bb );
688 abb_b_gold_attacks[ irank*nfile + ifile ] = bb;
691 set_attacks( irank+1, ifile-1, &bb );
692 set_attacks( irank+1, ifile+1, &bb );
693 set_attacks( irank+1, ifile, &bb );
694 set_attacks( irank-1, ifile, &bb );
695 set_attacks( irank, ifile-1, &bb );
696 set_attacks( irank, ifile+1, &bb );
697 abb_w_gold_attacks[ irank*nfile + ifile ] = bb;
700 set_attacks( irank+1, ifile-1, &bb );
701 set_attacks( irank+1, ifile+1, &bb );
702 set_attacks( irank+1, ifile, &bb );
703 set_attacks( irank-1, ifile-1, &bb );
704 set_attacks( irank-1, ifile+1, &bb );
705 set_attacks( irank-1, ifile, &bb );
706 set_attacks( irank, ifile-1, &bb );
707 set_attacks( irank, ifile+1, &bb );
708 abb_king_attacks[ irank*nfile + ifile ] = bb;
711 for ( irank = 0; irank < nrank; irank++ )
712 for ( ifile = 0; ifile < nfile; ifile++ )
715 set_attacks( irank-2, ifile-1, &bb );
716 set_attacks( irank-2, ifile+1, &bb );
717 abb_b_knight_attacks[ irank*nfile + ifile ] = bb;
720 for ( irank = 0; irank < nrank; irank++ )
721 for ( ifile = 0; ifile < nfile; ifile++ )
724 set_attacks( irank+2, ifile-1, &bb );
725 set_attacks( irank+2, ifile+1, &bb );
726 abb_w_knight_attacks[ irank*nfile + ifile ] = bb;
729 for ( irank = 0; irank < nrank; irank++ )
730 for ( ifile = 0; ifile < nrank; ifile++ )
731 for ( pcs = 0; pcs < 128; pcs++ )
734 for ( i = -1; irank+i >= 0; i-- )
736 set_attacks( irank+i, ifile, &bb );
737 if ( (pcs<<1) & (1 << (8-irank-i)) ) { break; }
739 for ( i = 1; irank+i <= 8; i++ )
741 set_attacks( irank+i, ifile, &bb );
742 if ( (pcs<<1) & (1 << (8-irank-i)) ) { break; }
744 abb_file_attacks[irank*nfile+ifile][pcs] = bb;
747 for ( irank = 0; irank < nrank; irank++ )
748 for ( ifile = 0; ifile < nrank; ifile++ )
749 for ( pcs = 0; pcs < 128; pcs++ )
752 for ( i = -1; ifile+i >= 0; i-- )
754 set_attacks( irank, ifile+i, &bb );
755 if ( (pcs<<1) & (1 << (8-ifile-i)) ) { break; }
757 for ( i = 1; ifile+i <= 8; i++ )
759 set_attacks( irank, ifile+i, &bb );
760 if ( (pcs<<1) & (1 << (8-ifile-i)) ) { break; }
762 ai_rook_attacks_r0[irank*nfile+ifile][pcs] = bb.p[irank/3];
765 for ( irank = 0; irank < nrank; irank++ )
766 for ( ifile = 0; ifile < nrank; ifile++ )
767 for ( pcs = 0; pcs < 128; pcs++ )
770 if ( ifile <= irank )
772 for ( i = -1; ifile+i >= 0; i-- )
774 set_attacks( irank+i, ifile+i, &bb );
775 if ( (pcs<<1) & (1 << (8-ifile-i)) ) { break; }
777 for ( i = 1; irank+i <= 8; i++ )
779 set_attacks( irank+i, ifile+i, &bb );
780 if ( (pcs<<1) & (1 << (8-ifile-i)) ) { break; }
784 for ( i = -1; irank+i >= 0; i-- )
786 set_attacks( irank+i, ifile+i, &bb );
787 if ( (pcs<<1) & (1 << (8-ifile-i)) ) { break; }
789 for ( i = 1; ifile+i <= 8; i++ )
791 set_attacks( irank+i, ifile+i, &bb );
792 if ( (pcs<<1) & (1 << (8-ifile-i)) ) { break; }
795 abb_bishop_attacks_rl45[irank*nfile+ifile][pcs] = bb;
798 for ( irank = 0; irank < nrank; irank++ )
799 for ( ifile = 0; ifile < nrank; ifile++ )
800 for ( pcs = 0; pcs < 128; pcs++ )
803 if ( ifile+irank >= 8 )
805 for ( i = -1; irank-i <= 8; i-- )
807 set_attacks( irank-i, ifile+i, &bb );
808 if ( (pcs<<1) & (1 << (irank-i)) ) { break; }
810 for ( i = 1; ifile+i <= 8; i++ )
812 set_attacks( irank-i, ifile+i, &bb );
813 if ( (pcs<<1) & (1 << (irank-i)) ) { break; }
817 for ( i = -1; ifile+i >= 0; i-- )
819 set_attacks( irank-i, ifile+i, &bb );
820 if ( (pcs<<1) & (1 << (irank-i)) ) { break; }
822 for ( i = 1; irank-i >= 0; i++ )
824 set_attacks( irank-i, ifile+i, &bb );
825 if ( (pcs<<1) & (1 << (irank-i)) ) { break; }
828 abb_bishop_attacks_rr45[irank*nfile+ifile][pcs] = bb;
831 for ( i = 0; i < nsquare; i++ )
833 aslide[i].ir0 = (unsigned char)(i/27);
834 aslide[i].sr0 = (unsigned char)((2-(i/9)%3)*9+1);
835 aslide[i].irl90 = (unsigned char)(2-(i%9)/3);
836 aslide[i].srl90 = (unsigned char)(((i%9)%3)*9+1);
839 for ( irank = 0; irank < nrank; irank++ )
840 for ( ifile = 0; ifile < nfile; ifile++ )
842 if ( irank >= ifile )
844 aslide[ irank*nfile+ifile ].irl45
845 = (unsigned char)((irank-ifile)/3);
846 aslide[ irank*nfile+ifile ].srl45
847 = (unsigned char)((2-((irank-ifile)%3))*9+1);
850 aslide[ irank*nfile+ifile ].irl45
851 = (unsigned char)((9+irank-ifile)/3);
852 aslide[ irank*nfile+ifile ].srl45
853 = (unsigned char)((2-((9+irank-ifile)%3))*9+1);
857 for ( irank = 0; irank < nrank; irank++ )
858 for ( ifile = 0; ifile < nfile; ifile++ )
860 if ( ifile+irank >= 8 )
862 aslide[ irank*nfile+ifile ].irr45
863 = (unsigned char)((irank+ifile-8)/3);
864 aslide[ irank*nfile+ifile ].srr45
865 = (unsigned char)((2-((irank+ifile-8)%3))*9+1);
868 aslide[ irank*nfile+ifile ].irr45
869 = (unsigned char)((irank+ifile+1)/3);
870 aslide[ irank*nfile+ifile ].srr45
871 = (unsigned char)((2-((irank+ifile+1)%3))*9+1);
878 set_attacks( int irank, int ifile, bitboard_t *pbb )
880 if ( irank >= rank1 && irank <= rank9 && ifile >= file1 && ifile <= file9 )
882 Xor( irank*nfile + ifile, *pbb );
888 bb_set_mask( int isquare )
894 bb.p[0] = bb.p[1] = 0;
895 bb.p[2] = 1U << (80-isquare);
897 else if ( isquare > 26 )
899 bb.p[0] = bb.p[2] = 0;
900 bb.p[1] = 1U << (53-isquare);
903 bb.p[1] = bb.p[2] = 0;
904 bb.p[0] = 1U << (26-isquare);
912 ini_check_table( void )
914 bitboard_t bb_check, bb;
917 for ( iking = 0; iking < nsquare; iking++ )
920 BBIni( b_chk_tbl[iking].gold );
921 bb_check = abb_w_gold_attacks[iking];
922 while ( BBToU(bb_check) )
924 icheck = LastOne( bb_check );
925 BBOr( b_chk_tbl[iking].gold, b_chk_tbl[iking].gold,
926 abb_w_gold_attacks[icheck] );
927 Xor( icheck, bb_check );
929 BBOr( bb, abb_mask[iking], abb_w_gold_attacks[iking] );
931 BBAnd( b_chk_tbl[iking].gold, b_chk_tbl[iking].gold, bb );
934 BBIni( b_chk_tbl[iking].silver );
935 bb_check = abb_w_silver_attacks[iking];
936 while ( BBToU(bb_check) )
938 icheck = LastOne( bb_check );
939 BBOr( b_chk_tbl[iking].silver, b_chk_tbl[iking].silver,
940 abb_w_silver_attacks[icheck] );
941 Xor( icheck, bb_check );
943 bb_check.p[0] = abb_w_gold_attacks[iking].p[0];
944 while ( bb_check.p[0] )
946 icheck = last_one0( bb_check.p[0] );
947 BBOr( b_chk_tbl[iking].silver, b_chk_tbl[iking].silver,
948 abb_w_silver_attacks[icheck] );
949 bb_check.p[0] ^= abb_mask[icheck].p[0];
951 bb_check.p[1] = abb_w_gold_attacks[iking].p[1];
952 while ( bb_check.p[1] )
954 icheck = last_one1( bb_check.p[1] );
955 b_chk_tbl[iking].silver.p[0]
956 |= abb_w_silver_attacks[icheck].p[0];
957 bb_check.p[1] ^= abb_mask[icheck].p[1];
959 BBOr( bb, abb_mask[iking], abb_w_silver_attacks[iking] );
961 BBAnd( b_chk_tbl[iking].silver, b_chk_tbl[iking].silver, bb );
964 BBIni( b_chk_tbl[iking].knight );
965 bb_check = abb_w_knight_attacks[iking];
966 while ( BBToU(bb_check) )
968 icheck = LastOne( bb_check );
969 BBOr( b_chk_tbl[iking].knight, b_chk_tbl[iking].knight,
970 abb_w_knight_attacks[icheck] );
971 Xor( icheck, bb_check );
973 bb_check.p[0] = abb_w_gold_attacks[iking].p[0];
974 while ( bb_check.p[0] )
976 icheck = last_one0( bb_check.p[0] );
977 BBOr( b_chk_tbl[iking].knight, b_chk_tbl[iking].knight,
978 abb_w_knight_attacks[icheck] );
979 bb_check.p[0] ^= abb_mask[icheck].p[0];
984 BBAnd( b_chk_tbl[iking].lance, abb_plus_rays[iking+nfile],
985 abb_file_attacks[iking][0] );
986 if ( iking <= I7 && iking != A9 && iking != A8 && iking != A7 ) {
987 BBAnd( bb, abb_plus_rays[iking-1], abb_file_attacks[iking-1][0] );
988 BBOr( b_chk_tbl[iking].lance, b_chk_tbl[iking].lance, bb );
990 if ( iking <= I7 && iking != I9 && iking != I8 && iking != I7 ) {
991 BBAnd( bb, abb_plus_rays[iking+1], abb_file_attacks[iking+1][0] );
992 BBOr( b_chk_tbl[iking].lance, b_chk_tbl[iking].lance, bb );
994 } else { BBIni( b_chk_tbl[iking].lance ); }
997 BBIni( w_chk_tbl[iking].gold );
998 bb_check = abb_b_gold_attacks[iking];
999 while ( BBToU(bb_check) )
1001 icheck = LastOne( bb_check );
1002 BBOr( w_chk_tbl[iking].gold, w_chk_tbl[iking].gold,
1003 abb_b_gold_attacks[icheck] );
1004 Xor( icheck, bb_check );
1006 BBOr( bb, abb_mask[iking], abb_b_gold_attacks[iking] );
1008 BBAnd( w_chk_tbl[iking].gold, w_chk_tbl[iking].gold, bb );
1011 BBIni( w_chk_tbl[iking].silver );
1012 bb_check = abb_b_silver_attacks[iking];
1013 while ( BBToU(bb_check) )
1015 icheck = LastOne( bb_check );
1016 BBOr( w_chk_tbl[iking].silver, w_chk_tbl[iking].silver,
1017 abb_b_silver_attacks[icheck] );
1018 Xor( icheck, bb_check );
1020 bb_check.p[2] = abb_b_gold_attacks[iking].p[2];
1021 while ( bb_check.p[2] )
1023 icheck = first_one2( bb_check.p[2] );
1024 BBOr( w_chk_tbl[iking].silver, w_chk_tbl[iking].silver,
1025 abb_b_silver_attacks[icheck] );
1026 bb_check.p[2] ^= abb_mask[icheck].p[2];
1028 bb_check.p[1] = abb_b_gold_attacks[iking].p[1];
1029 while ( bb_check.p[1] )
1031 icheck = first_one1( bb_check.p[1] );
1032 w_chk_tbl[iking].silver.p[2]
1033 |= abb_b_silver_attacks[icheck].p[2];
1034 bb_check.p[1] ^= abb_mask[icheck].p[1];
1036 BBOr( bb, abb_mask[iking], abb_b_silver_attacks[iking] );
1038 BBAnd( w_chk_tbl[iking].silver, w_chk_tbl[iking].silver, bb );
1041 BBIni( w_chk_tbl[iking].knight );
1042 bb_check = abb_b_knight_attacks[iking];
1043 while ( BBToU(bb_check) )
1045 icheck = LastOne( bb_check );
1046 BBOr( w_chk_tbl[iking].knight, w_chk_tbl[iking].knight,
1047 abb_b_knight_attacks[icheck] );
1048 Xor( icheck, bb_check );
1050 bb_check.p[2] = abb_b_gold_attacks[iking].p[2];
1051 while ( bb_check.p[2] )
1053 icheck = first_one2( bb_check.p[2] );
1054 BBOr( w_chk_tbl[iking].knight, w_chk_tbl[iking].knight,
1055 abb_b_knight_attacks[icheck] );
1056 bb_check.p[2] ^= abb_mask[icheck].p[2];
1060 if ( iking >= A7 ) {
1061 BBAnd( w_chk_tbl[iking].lance, abb_minus_rays[iking-nfile],
1062 abb_file_attacks[iking][0] );
1063 if ( iking >= A3 && iking != A3 && iking != A2 && iking != A1 ) {
1064 BBAnd( bb, abb_minus_rays[iking-1], abb_file_attacks[iking-1][0] );
1065 BBOr( w_chk_tbl[iking].lance, w_chk_tbl[iking].lance, bb );
1067 if ( iking >= A3 && iking != I3 && iking != I2 && iking != I1 ) {
1068 BBAnd( bb, abb_minus_rays[iking+1], abb_file_attacks[iking+1][0] );
1069 BBOr( w_chk_tbl[iking].lance, w_chk_tbl[iking].lance, bb );
1071 } else { BBIni( w_chk_tbl[iking].lance ); }
1076 #if defined(_MSC_VER)
1077 #elif defined(__GNUC__) && ( defined(__i386__) || defined(__x86_64__) )
1080 first_one00( int pcs )
1084 for ( i = 0; i < 9; i++ ) { if ( pcs & (1<<(8-i)) ) { break; } }
1090 last_one00( int pcs )
1094 for ( i = 8; i >= 0; i-- ) { if ( pcs & (1<<(8-i)) ) { break; } }