void turn_left(void) { reset_counter(LEFT); reset_counter(RIGHT); while(read_encoder_counter(RIGHT) < (int)(QUARTER_TURN+0.5) && read_encoder_counter(LEFT) < (int)(QUARTER_TURN-0.5)) { ahead_R(); back_L(); control(); } if (read_encoder_counter(RIGHT) < (int)(QUARTER_TURN+0.5) ) { stop_motor_L(); while (read_encoder_counter(RIGHT) < (int)(QUARTER_TURN+0.5) ) { ahead_R(); } stop_motor_R(); } else if (read_encoder_counter(LEFT) < (int)(QUARTER_TURN-0.5) ) { stop_motor_R(); while (read_encoder_counter(LEFT) < (int)(QUARTER_TURN-0.5) ) { back_L(); } stop_motor_L(); } }
void user_rf_pre_init(void) { RESET_COUNTER counter; if(system_get_rst_info()->reason != REASON_EXT_SYS_RST) { reset_counter(0); } else { system_rtc_mem_read(64, &counter, sizeof(counter)); if(counter.magic == RESET_COUNTER_MAGIC && counter.resetCounter <= RESET_NUM) { counter.resetCounter++; if(counter.resetCounter == RESET_NUM) { reset_counter(0); mSpecialMode = 1; } else { system_rtc_mem_write(RESET_COUNTER_RTC_ADDRESS, &counter, sizeof(counter)); os_timer_disarm(&mResetTimer); os_timer_setfn(&mResetTimer, (os_timer_func_t *)reset_counter, NULL); os_timer_arm(&mResetTimer, 1000, 0); } } else { reset_counter(0); } } system_restore(); rtc_mem_check(0); }
void ahead(void) { reset_counter(LEFT); reset_counter(RIGHT); while(read_encoder_counter(RIGHT) < MOVE_DURATION && read_encoder_counter(LEFT) < MOVE_DURATION) { ahead_R(); ahead_L(); control(); } if (read_encoder_counter(RIGHT) < MOVE_DURATION ) { stop_motor_L(); while (read_encoder_counter(RIGHT) < MOVE_DURATION ) { ahead_R(); } stop_motor_R(); } else if (read_encoder_counter(LEFT) < MOVE_DURATION ) { stop_motor_R(); while (read_encoder_counter(LEFT) < MOVE_DURATION ) { ahead_L(); } stop_motor_L(); } }
tower::tower(const tower_attributes &attributes,double posx,double posy,const ALLEGRO_TIMER *timer) { this->attributes=&attributes; this->position=make_pair(posx,posy); this->timer=timer; set_delay(); reset_counter(); active=true; }
tower_atk tower::attack(const pair<double,double> target) { if(atk_counter>0) debug_log::report("tower attack before counter reach 0",warning,true,false,false); if(in_range(target)==false) debug_log::report("tower attack out of range",warning,true,false,false); reset_counter(); unsigned int hoffset=get_bitmap_height(attributes->bitmap)/3; pair<double,double> pos=position; pos.second-=hoffset*2; return tower_atk(attributes->atk,pos,target,timer); }
void game_init( const char *file_name, int *side_to_move ) { setup_game( file_name, side_to_move ); setup_search(); setup_midgame(); setup_end(); init_eval(); clear_ponder_times(); reset_counter( &total_nodes ); reset_counter( &total_evaluations ); init_flip_stack(); total_time = 0.0; max_depth_reached = 0; last_time_used = 0.0; endgame_performed[BLACKSQ] = endgame_performed[WHITESQ] = FALSE; }
static bool reset_timers() { //this function should only be called from an atomic context if(NG(next_event) == NO_EVENT) { reset_counter(); return true; } timer_tick_t cur_value = timer_get_counter_value(); reset_counter(); for(uint32_t i = 0; i < FRAMEWORK_TIMER_STACK_SIZE; i++) { if(NG(timers)[i].f != 0x0) { //prevent the value from 'underflowing' if(cur_value > NG(timers)[i].next_event) NG(timers)[i].next_event = 0; else NG(timers)[i].next_event -= cur_value; } } return true; }
void select_clicked(ClickRecognizerRef recognizer, void* context) { reset_counter(); display_counter(); }
void perform_extended_solve( int side_to_move, int actual_move, int book, int exact_solve ) { int i; int mid, wld, exact; int best_move; int disc_diff, corrected_diff; EvaluatedMove temp; EvalResult res; /* Disable all time control mechanisms */ toggle_abort_check( FALSE ); toggle_midgame_abort_check( FALSE ); toggle_perturbation_usage( FALSE ); start_move( 0, 0, disc_count( BLACKSQ ) + disc_count( WHITESQ ) ); clear_ponder_times(); determine_hash_values( side_to_move, board ); reset_counter( &nodes ); /* Set search depths that result in Zebra solving after a brief midgame analysis */ mid = 60; wld = 60; if ( exact_solve ) exact = 60; else exact = 0; game_evaluated_count = 1; /* Calculate the score for the preferred move */ evaluated_list[0].side_to_move = side_to_move; evaluated_list[0].move = actual_move; evaluated_list[0].eval = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, FALSE ); evaluated_list[0].pv_depth = 1; evaluated_list[0].pv[0] = actual_move; prefix_move = actual_move; negate_current_eval( TRUE ); (void) make_move( side_to_move, actual_move, TRUE ); (void) compute_move( OPP( side_to_move ), FALSE, 0, 0, FALSE, book, mid - 1, exact - 1, wld - 1, TRUE, &evaluated_list[0].eval ); if ( evaluated_list[0].eval.type == PASS_EVAL ) { /* Don't allow pass */ (void) compute_move( side_to_move, FALSE, 0, 0, FALSE, book, mid - 1, exact - 1, wld - 1, TRUE, &evaluated_list[0].eval ); if ( evaluated_list[0].eval.type == PASS_EVAL ) { /* Game has ended */ disc_diff = disc_count( side_to_move ) - disc_count( OPP( side_to_move ) ); if ( disc_diff > 0 ) { corrected_diff = 64 - 2 * disc_count( OPP( side_to_move) ); res = WON_POSITION; } else if ( disc_diff == 0 ) { corrected_diff = 0; res = DRAWN_POSITION; } else { corrected_diff = 2 * disc_count( side_to_move ) - 64; res = LOST_POSITION; } evaluated_list[0].eval = create_eval_info( EXACT_EVAL, res, 128 * corrected_diff, 0.0, 60 - disks_played, FALSE ); } } else { /* Sign-correct the score produced */ evaluated_list[0].eval.score = -evaluated_list[0].eval.score; if ( evaluated_list[0].eval.res == WON_POSITION ) evaluated_list[0].eval.res = LOST_POSITION; else if ( evaluated_list[0].eval.res == LOST_POSITION ) evaluated_list[0].eval.res = WON_POSITION; } if ( force_return ) evaluated_list[0].eval = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, FALSE ); else { evaluated_list[0].pv_depth = pv_depth[0] + 1; evaluated_list[0].pv[0] = actual_move; for ( i = 0; i < pv_depth[0]; i++ ) evaluated_list[0].pv[i + 1] = pv[0][i]; } unmake_move( side_to_move, actual_move ); prefix_move = 0; negate_current_eval( FALSE ); max_depth_reached++; /* Compute the score for the best move and store it in the move list if it isn't ACTUAL_MOVE */ best_move = compute_move( side_to_move, FALSE, 0, 0, FALSE, book, mid, exact, wld, TRUE, &evaluated_list[1].eval ); if ( !force_return && (best_move != actual_move) ) { /* Move list will contain best move first and then the actual move */ game_evaluated_count = 2; evaluated_list[1].side_to_move = side_to_move; evaluated_list[1].move = best_move; evaluated_list[1].pv_depth = pv_depth[0]; for ( i = 0; i < pv_depth[0]; i++ ) evaluated_list[1].pv[i] = pv[0][i]; temp = evaluated_list[0]; evaluated_list[0] = evaluated_list[1]; evaluated_list[1] = temp; } /* The PV and current eval should when correspond to the best move when leaving */ pv_depth[0] = evaluated_list[0].pv_depth; for ( i = 0; i < pv_depth[0]; i++ ) pv[0][i] = evaluated_list[0].pv[i]; set_current_eval( evaluated_list[0].eval ); /* Don't forget to enable the time control mechanisms when leaving */ toggle_abort_check( TRUE ); toggle_midgame_abort_check( TRUE ); toggle_perturbation_usage( FALSE ); }
int extended_compute_move( int side_to_move, int book_only, int book, int mid, int exact, int wld ) { int i, j; int index; int changed; int this_move; int disc_diff, corrected_diff; int best_move, temp_move; int best_score; int best_pv_depth; int stored_echo; int shallow_eval; int empties; int current_mid, current_exact, current_wld; int first_iteration; int unsearched; int unsearched_count; int unsearched_move[61]; int best_pv[60]; unsigned int transform1[60], transform2[60]; CandidateMove book_move; EvaluatedMove temp; EvaluationType book_eval_info; EvalResult res; /* Disable all time control mechanisms and randomization */ toggle_abort_check( FALSE ); toggle_midgame_abort_check( FALSE ); toggle_perturbation_usage( FALSE ); start_move( 0, 0, disc_count( BLACKSQ ) + disc_count( WHITESQ ) ); clear_ponder_times(); determine_hash_values( side_to_move, board ); empties = 60 - disks_played; best_move = 0; game_evaluated_count = 0; reset_counter( &nodes ); generate_all( side_to_move ); if ( book_only || book ) { /* Evaluations for database moves */ int flags = 0; if ( empties <= exact ) flags = FULL_SOLVED; else if ( empties <= wld ) flags = WLD_SOLVED; fill_move_alternatives( side_to_move, flags ); game_evaluated_count = get_candidate_count(); for ( i = 0; i < game_evaluated_count; i++ ) { int child_flags; book_move = get_candidate( i ); evaluated_list[i].side_to_move = side_to_move; evaluated_list[i].move = book_move.move; evaluated_list[i].pv_depth = 1; evaluated_list[i].pv[0] = book_move.move; evaluated_list[i].eval = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, book_move.score, 0.0, 0, TRUE ); child_flags = book_move.flags & book_move.parent_flags; if ( child_flags & (FULL_SOLVED | WLD_SOLVED) ) { if ( child_flags & FULL_SOLVED ) evaluated_list[i].eval.type = EXACT_EVAL; else evaluated_list[i].eval.type = WLD_EVAL; if ( book_move.score > 0 ) { evaluated_list[i].eval.res = WON_POSITION; /* Normalize the scores so that e.g. 33-31 becomes +256 */ evaluated_list[i].eval.score -= CONFIRMED_WIN; evaluated_list[i].eval.score *= 128; } else if ( book_move.score == 0 ) evaluated_list[i].eval.res = DRAWN_POSITION; else { /* score < 0 */ evaluated_list[i].eval.res = LOST_POSITION; /* Normalize the scores so that e.g. 30-34 becomes -512 */ evaluated_list[i].eval.score += CONFIRMED_WIN; evaluated_list[i].eval.score *= 128; } } else evaluated_list[i].eval.type = MIDGAME_EVAL; } } if ( book_only ) { /* Only book moves are to be considered */ if ( game_evaluated_count > 0 ) { best_move = get_book_move( side_to_move, FALSE, &book_eval_info ); set_current_eval( book_eval_info ); } else { pv_depth[0] = 0; best_move = PASS; book_eval_info = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, FALSE ); set_current_eval( book_eval_info ); } } else { /* Make searches for moves not in the database */ int shallow_depth; int empties = 60 - disks_played; book = FALSE; best_score = -INFINITE_EVAL; if ( game_evaluated_count > 0 ) { /* Book PV available */ best_score = evaluated_list[0].eval.score; best_move = evaluated_list[0].move; } negate_current_eval( TRUE ); /* Store the available moves, clear their evaluations and sort them on shallow evaluation. */ if ( empties < 12 ) shallow_depth = 1; else { int max_depth = MAX( mid, MAX( exact, wld ) ); if ( max_depth >= 16 ) shallow_depth = 6; else shallow_depth = 4; } unsearched_count = 0; for ( i = 0; i < move_count[disks_played]; i++ ) { this_move = move_list[disks_played][i]; unsearched = TRUE; for ( j = 0; j < game_evaluated_count; j++ ) if ( evaluated_list[j].move == this_move ) unsearched = FALSE; if ( !unsearched ) continue; unsearched_move[unsearched_count] = this_move; unsearched_count++; (void) make_move( side_to_move, this_move, TRUE ); if ( shallow_depth == 1 ) /* Compute move doesn't allow depth 0 */ shallow_eval = -static_evaluation( OPP( side_to_move ) ); else { EvaluationType shallow_info; (void) compute_move( OPP( side_to_move ), FALSE, 0, 0, FALSE, book, shallow_depth - 1, 0, 0, TRUE, &shallow_info ); if ( shallow_info.type == PASS_EVAL ) { /* Don't allow pass */ (void) compute_move( side_to_move, FALSE, 0, 0, FALSE, book, shallow_depth - 1, 0, 0, TRUE, &shallow_info ); if ( shallow_info.type == PASS_EVAL ) { /* Game over */ disc_diff = disc_count( side_to_move ) - disc_count( OPP( side_to_move ) ); if ( disc_diff > 0 ) corrected_diff = 64 - 2 * disc_count( OPP( side_to_move) ); else if ( disc_diff == 0 ) corrected_diff = 0; else corrected_diff = 2 * disc_count( side_to_move ) - 64; shallow_eval = 128 * corrected_diff; } else shallow_eval = shallow_info.score; } else /* Sign-correct the score produced */ shallow_eval = -shallow_info.score; } unmake_move( side_to_move, this_move ); evals[disks_played][this_move] = shallow_eval; } do { changed = FALSE; for ( i = 0; i < unsearched_count - 1; i++ ) if ( evals[disks_played][unsearched_move[i]] < evals[disks_played][unsearched_move[i + 1]] ) { temp_move = unsearched_move[i]; unsearched_move[i] = unsearched_move[i + 1]; unsearched_move[i + 1] = temp_move; changed = TRUE; } } while ( changed ); /* Initialize the entire list as being empty */ for ( i = 0, index = game_evaluated_count; i < unsearched_count; i++, index++ ) { evaluated_list[index].side_to_move = side_to_move; evaluated_list[index].move = unsearched_move[i]; evaluated_list[index].eval = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, FALSE ); evaluated_list[index].pv_depth = 1; evaluated_list[index].pv[0] = unsearched_move[i]; if ( empties > MAX( wld, exact ) ) { transform1[i] = abs( my_random() ); transform2[i] = abs( my_random() ); } else { transform1[i] = 0; transform2[i] = 0; } } stored_echo = echo; echo = FALSE; best_pv_depth = 0; if ( mid == 1 ) { /* compute_move won't be called */ pv_depth[0] = 0; piece_count[BLACKSQ][disks_played] = disc_count( BLACKSQ ); piece_count[WHITESQ][disks_played] = disc_count( WHITESQ ); } /* Perform iterative deepening if the search depth is large enough */ #define ID_STEP 2 if ( exact > empties ) exact = empties; if ( (exact < 12) || (empties > exact) ) current_exact = exact; else current_exact = (8 + (exact % 2)) - ID_STEP; if ( wld > empties ) wld = empties; if ( (wld < 14) || (empties > wld) ) current_wld = wld; else current_wld = (10 + (wld % 2)) - ID_STEP; if ( ((empties == exact) || (empties == wld)) && (empties > 16) && (mid < empties - 12) ) mid = empties - 12; if ( mid < 10 ) current_mid = mid; else current_mid = (6 + (mid % 2)) - ID_STEP; first_iteration = TRUE; do { if ( current_mid < mid ) { current_mid += ID_STEP; /* Avoid performing deep midgame searches if the endgame is reached anyway. */ if ( (empties <= wld) && (current_mid + 7 >= empties) ) { current_wld = wld; current_mid = mid; } if ( (empties <= exact) && (current_mid + 7 >= empties) ) { current_exact = exact; current_mid = mid; } } else if ( current_wld < wld ) current_wld = wld; else current_exact = exact; for ( i = 0; (i < unsearched_count) && !force_return; i++ ) { EvaluationType this_eval; this_move = unsearched_move[i]; /* Locate the current move in the list. This has to be done because the moves might have been reordered during the iterative deepening. */ index = 0; while ( evaluated_list[index].move != this_move ) index++; /* To avoid strange effects when browsing back and forth through a game during the midgame, rehash the hash transformation masks for each move unless the endgame is reached */ set_hash_transformation( transform1[i], transform2[i] ); /* Determine the score for the ith move */ prefix_move = this_move; (void) make_move( side_to_move, this_move, TRUE ); if ( current_mid == 1 ) { /* compute_move doesn't like 0-ply searches */ shallow_eval = static_evaluation( OPP( side_to_move ) ); this_eval = create_eval_info( MIDGAME_EVAL, UNSOLVED_POSITION, shallow_eval, 0.0, 0, FALSE ); } else (void) compute_move( OPP( side_to_move ), FALSE, 0, 0, FALSE, book, current_mid - 1, current_exact - 1, current_wld - 1, TRUE, &this_eval ); if ( force_return ) { /* Clear eval and exit search immediately */ this_eval = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, FALSE ); unmake_move( side_to_move, this_move ); break; } if ( this_eval.type == PASS_EVAL ) { /* Don't allow pass */ if ( current_mid == 1 ) { /* compute_move doesn't like 0-ply searches */ shallow_eval = static_evaluation( side_to_move ); this_eval = create_eval_info( MIDGAME_EVAL, UNSOLVED_POSITION, shallow_eval, 0.0, 0, FALSE ); } else (void) compute_move( side_to_move, FALSE, 0, 0, FALSE, book, current_mid - 1, current_exact - 1, current_wld - 1, TRUE, &this_eval ); if ( this_eval.type == PASS_EVAL ) { /* Game over */ disc_diff = disc_count( side_to_move ) - disc_count( OPP( side_to_move ) ); if ( disc_diff > 0 ) { corrected_diff = 64 - 2 * disc_count( OPP( side_to_move) ); res = WON_POSITION; } else if ( disc_diff == 0 ) { corrected_diff = 0; res = DRAWN_POSITION; } else { corrected_diff = 2 * disc_count( side_to_move ) - 64; res = LOST_POSITION; } this_eval = create_eval_info( EXACT_EVAL, res, 128 * corrected_diff, 0.0, 60 - disks_played, FALSE ); } } else { /* Sign-correct the score produced */ this_eval.score = -this_eval.score; if ( this_eval.res == WON_POSITION ) this_eval.res = LOST_POSITION; else if ( this_eval.res == LOST_POSITION ) this_eval.res = WON_POSITION; } if ( force_return ) break; else evaluated_list[index].eval = this_eval; /* Store the PV corresponding to the move */ evaluated_list[index].pv_depth = pv_depth[0] + 1; evaluated_list[index].pv[0] = this_move; for ( j = 0; j < pv_depth[0]; j++ ) evaluated_list[index].pv[j + 1] = pv[0][j]; /* Store the PV corresponding to the best move */ if ( evaluated_list[index].eval.score > best_score ) { best_score = evaluated_list[index].eval.score; best_move = this_move; best_pv_depth = pv_depth[0]; for ( j = 0; j < best_pv_depth; j++ ) best_pv[j] = pv[0][j]; } unmake_move( side_to_move, this_move ); /* Sort the moves evaluated */ if ( first_iteration ) game_evaluated_count++; if ( !force_return ) do { changed = FALSE; for ( j = 0; j < game_evaluated_count - 1; j++ ) if ( compare_eval( evaluated_list[j].eval, evaluated_list[j + 1].eval ) < 0 ) { changed = TRUE; temp = evaluated_list[j]; evaluated_list[j] = evaluated_list[j + 1]; evaluated_list[j + 1] = temp; } } while ( changed ); display_status(stdout, FALSE); } first_iteration = FALSE; /* Reorder the moves after each iteration. Each move is moved to the front of the list, starting with the bad moves and ending with the best move. This ensures that unsearched_move will be sorted w.r.t. the order in evaluated_list. */ for ( i = game_evaluated_count - 1; i >= 0; i-- ) { int this_move = evaluated_list[i].move; j = 0; while ( (j != unsearched_count) && (unsearched_move[j] != this_move) ) j++; if ( j == unsearched_count ) /* Must be book move, skip */ continue; /* Move the move to the front of the list. */ while ( j >= 1 ) { unsearched_move[j] = unsearched_move[j - 1]; j--; } unsearched_move[0] = this_move; } } while ( !force_return && ((current_mid != mid) || (current_exact != exact) || (current_wld != wld)) ); echo = stored_echo; game_evaluated_count = move_count[disks_played]; /* Make sure that the PV and the score correspond to the best move */ pv_depth[0] = best_pv_depth + 1; pv[0][0] = best_move; for ( i = 0; i < best_pv_depth; i++ ) pv[0][i + 1] = best_pv[i]; negate_current_eval( FALSE ); if ( move_count[disks_played] > 0 ) set_current_eval( evaluated_list[0].eval ); } /* Reset the hash transformation masks prior to leaving */ set_hash_transformation( 0, 0 ); /* Don't forget to enable the time control mechanisms when leaving */ toggle_abort_check( TRUE ); toggle_midgame_abort_check( TRUE ); toggle_perturbation_usage( TRUE ); max_depth_reached++; prefix_move = 0; return best_move; }
void ponder_move( int side_to_move, int book, int mid, int exact, int wld ) { EvaluationType eval_info; HashEntry entry; double move_start_time, move_stop_time; int i, j; int this_move, hash_move; int expect_count; int stored_echo; int best_pv_depth; int expect_list[64]; int best_pv[61]; /* Disable all time control mechanisms as it's the opponent's time we're using */ toggle_abort_check( FALSE ); toggle_midgame_abort_check( FALSE ); start_move( 0, 0, disc_count( BLACKSQ ) + disc_count( WHITESQ ) ); clear_ponder_times(); determine_hash_values( side_to_move, board ); reset_counter( &nodes ); /* Find the scores for the moves available to the opponent. */ hash_move = 0; find_hash( &entry, ENDGAME_MODE ); if ( entry.draft != NO_HASH_MOVE ) hash_move = entry.move[0]; else { find_hash( &entry, MIDGAME_MODE ); if ( entry.draft != NO_HASH_MOVE ) hash_move = entry.move[0]; } stored_echo = echo; echo = FALSE; (void) compute_move( side_to_move, FALSE, 0, 0, FALSE, FALSE, MIN( PONDER_DEPTH, mid ), 0, 0, FALSE, &eval_info ); echo = stored_echo; /* Sort the opponents on the score and push the table move (if any) to the front of the list */ if ( force_return ) expect_count = 0; else { sort_moves( move_count[disks_played] ); (void) float_move( hash_move, move_count[disks_played] ); expect_count = move_count[disks_played]; for ( i = 0; i < expect_count; i++ ) expect_list[i] = move_list[disks_played][i]; #if TEXT_BASED printf( "%s=%d\n", HASH_MOVE_TEXT, hash_move ); for ( i = 0; i < expect_count; i++ ) { printf( "%c%c %-6.2f ", TO_SQUARE( move_list[disks_played][i] ), evals[disks_played][move_list[disks_played][i]] / 128.0 ); if ( (i % 7 == 6) || (i == expect_count - 1) ) puts( "" ); } #endif } /* Go through the expected moves in order and prepare responses. */ best_pv_depth = 0; for ( i = 0; !force_return && (i < expect_count); i++ ) { move_start_time = get_real_timer(); set_ponder_move( expect_list[i] ); this_move = expect_list[i]; prefix_move = this_move; (void) make_move( side_to_move, this_move, TRUE ); (void) compute_move( OPP( side_to_move ), FALSE, 0, 0, TRUE, FALSE, mid, exact, wld, FALSE, &eval_info ); unmake_move( side_to_move, this_move ); clear_ponder_move(); move_stop_time = get_real_timer(); add_ponder_time( expect_list[i], move_stop_time - move_start_time ); ponder_depth[expect_list[i]] = MAX( ponder_depth[expect_list[i]], max_depth_reached - 1 ); if ( (i == 0) && !force_return ) { /* Store the PV for the first move */ best_pv_depth = pv_depth[0]; for ( j = 0; j < pv_depth[0]; j++ ) best_pv[j] = pv[0][j]; } } /* Make sure the PV looks reasonable when leaving - either by clearing it altogether or, preferrably, using the stored PV for the first move if it is available. */ max_depth_reached++; prefix_move = 0; if ( best_pv_depth == 0 ) pv_depth[0] = 0; else { pv_depth[0] = best_pv_depth + 1; pv[0][0] = expect_list[0]; for ( i = 0; i < best_pv_depth; i++ ) pv[0][i + 1] = best_pv[i]; } /* Don't forget to enable the time control mechanisms when leaving */ toggle_abort_check( TRUE ); toggle_midgame_abort_check( TRUE ); }
int compute_move( int side_to_move, int update_all, int my_time, int my_incr, int timed_depth, int book, int mid, int exact, int wld, int search_forced, EvaluationType *eval_info ) { FILE *log_file; EvaluationType book_eval_info, mid_eval_info, end_eval_info; char *eval_str; double midgame_diff; enum { INTERRUPTED_MOVE, BOOK_MOVE, MIDGAME_MOVE, ENDGAME_MOVE } move_type; int i; int curr_move, midgame_move; int empties; int midgame_depth, interrupted_depth, max_depth; int book_move_found; int endgame_reached; int offset; log_file = NULL; if ( use_log_file ) log_file = fopen( log_file_path, "a" ); if ( log_file ) display_board( log_file, board, side_to_move, FALSE, FALSE, FALSE ); /* Initialize various components of the move system */ piece_count[BLACKSQ][disks_played] = disc_count( BLACKSQ ); piece_count[WHITESQ][disks_played] = disc_count( WHITESQ ); init_moves(); generate_all( side_to_move ); determine_hash_values( side_to_move, board ); calculate_perturbation(); if ( log_file ) { fprintf( log_file, "%d %s: ", move_count[disks_played], MOVE_GEN_TEXT ); for ( i = 0; i < move_count[disks_played]; i++ ) fprintf( log_file, "%c%c ", TO_SQUARE( move_list[disks_played][i] ) ); fputs( "\n", log_file ); } if ( update_all ) { reset_counter( &evaluations ); reset_counter( &nodes ); } for ( i = 0; i < 100; i++ ) evals[disks_played][i] = 0; max_depth_reached = 1; empties = 60 - disks_played; reset_buffer_display(); determine_move_time( my_time, my_incr, disks_played + 4 ); if ( !get_ponder_move() ) clear_ponder_times(); remove_coeffs( disks_played ); /* No feasible moves? */ if ( move_count[disks_played] == 0 ) { *eval_info = create_eval_info( PASS_EVAL, UNSOLVED_POSITION, 0.0, 0.0, 0, FALSE ); set_current_eval( *eval_info ); if ( echo ) { eval_str = produce_eval_text( *eval_info, FALSE ); send_status( "--> " ); send_status( "%-8s ", eval_str ); display_status( stdout, FALSE ); free( eval_str ); } if ( log_file ) { fprintf( log_file, "%s: %s\n", BEST_MOVE_TEXT, PASS_TEXT ); fclose( log_file ); } last_time_used = 0.0; clear_pv(); return PASS; } /* If there is only one move available: Don't waste any time, unless told so or very close to the end, searching the position. */ if ( (empties > DISABLE_FORCED_MOVES) && (move_count[disks_played] == 1) && !search_forced ) { /* Forced move */ *eval_info = create_eval_info( FORCED_EVAL, UNSOLVED_POSITION, 0.0, 0.0, 0, FALSE ); set_current_eval( *eval_info ); if ( echo ) { eval_str = produce_eval_text( *eval_info, FALSE ); send_status( "--> " ); send_status( "%-8s ", eval_str ); free( eval_str ); send_status( "%c%c ", TO_SQUARE( move_list[disks_played][0] ) ); display_status( stdout, FALSE ); } if ( log_file ) { fprintf( log_file, "%s: %c%c (%s)\n", BEST_MOVE_TEXT, TO_SQUARE(move_list[disks_played][0]), FORCED_TEXT ); fclose( log_file ); } last_time_used = 0.0; return move_list[disks_played][0]; } /* Mark the search as interrupted until a successful search has been performed. */ move_type = INTERRUPTED_MOVE; interrupted_depth = 0; curr_move = move_list[disks_played][0]; /* Check the opening book for midgame moves */ book_move_found = FALSE; midgame_move = PASS; if ( forced_opening != NULL ) { /* Check if the position fits the currently forced opening */ curr_move = check_forced_opening( side_to_move, forced_opening ); if ( curr_move != PASS ) { book_eval_info = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, TRUE ); midgame_move = curr_move; book_move_found = TRUE; move_type = BOOK_MOVE; if ( echo ) { send_status( "--> Forced opening move " ); if ( get_ponder_move() ) send_status( "{%c%c} ", TO_SQUARE( get_ponder_move() ) ); send_status( "%c%c", TO_SQUARE( curr_move ) ); display_status( stdout, FALSE ); } clear_pv(); pv_depth[0] = 1; pv[0][0] = curr_move; } } if ( !book_move_found && play_thor_match_openings ) { /* Optionally use the Thor database as opening book. */ int threshold = 2; database_search( board, side_to_move ); if ( get_match_count() >= threshold ) { int game_index = (my_random() >> 8) % get_match_count(); curr_move = get_thor_game_move( game_index, disks_played ); if ( valid_move( curr_move, side_to_move ) ) { book_eval_info = create_eval_info( UNDEFINED_EVAL, UNSOLVED_POSITION, 0, 0.0, 0, TRUE ); midgame_move = curr_move; book_move_found = TRUE; move_type = BOOK_MOVE; if ( echo ) { send_status( "--> %s ", THOR_TEXT ); if ( get_ponder_move() ) send_status( "{%c%c} ", TO_SQUARE( get_ponder_move() ) ); send_status( "%c%c", TO_SQUARE( curr_move ) ); display_status( stdout, FALSE ); } clear_pv(); pv_depth[0] = 1; pv[0][0] = curr_move; } else fatal_error( "Thor book move %d is invalid!", curr_move ); }
/* Einlesen und plotten der Trajektorien */ void plot_trajectories(struct state* state, struct trajectory* current) { double *plot_field; /* Plotmatrix fuer genau eine Trajektorie */ int i, j; plot_field = calloc(sizeof(double), state->field_max); if (plot_field == NULL) { printf("Out of memory!\n"); exit(1); } /* Unterordner fuer die Trajektorien in der KML-Ausgabedatei * anlegen */ fprintf(state->fh, "<Folder>\n"); fprintf(state->fh, "<name>Trajektorien</name>\n"); /* Einlesen aller Trajektorienaufpunkte in Trajektoriendichtenetz * und Ausgabe der Trajektorienverlaeufe in der KML-Datei */ for (i = 0; i < state->list_max; i++) { current->name = state->list[i]; /* Name der aktuellen Trajektorie schreiben und Unterordner * anlegen */ printf("%s\n", current->name); fprintf(state->fh, "<Folder>\n"); fprintf(state->fh, "<name>%s</name>\n", current->name); /* Weglesen des Trajektoriendatei-Headers und einlesen des ersten * Trajektorienpunkts */ get_trajectory_start_point(current); /* Uebernehmen der Startkoordinaten in die weitere * Berechnung */ current->x_old = current->x_begin; current->y_old = current->y_begin; /* Oeffnen der Ordnerstruktur zum Speichern der momentanen Trajektorie * in die KML-Datei und schreiben des Trajektorienstartpunkts */ print_trajectory_header(state->fh, current->x_begin, current->y_begin); /* Zuruecksetzen der Zaehlvariablen fuer das Einlesen der naechsten * Trajektorie */ reset_counter(current); /* Initialisieren der lokalen Abbildungsmatrix der Trajektorie */ init_field(plot_field, state->field_max); /* Einlesen und abbilden der Trajektorie auf der lokalen * Berechnungsnetzmatrix */ read_trajectory(current, state, plot_field); /* Addieren der Trajektorienabbildung der lokalen Abbildungsmatrix * zur Gesamtdarstellungsmatrix */ for (j = 0; j < state->field_max; j++) state->field_grid[j] += plot_field[j]; /* Aktuelle Trajektoriendatei schliessen */ fclose(current->fh); /* Struktur der aktuellen Trajektorie in der KML-Datei * schliessen */ fprintf(state->fh, "</coordinates>\n"); fprintf(state->fh, "</LineString>\n"); fprintf(state->fh, "</Placemark>\n"); fprintf(state->fh, "</Folder>\n\n"); } /* Unterordner fuer Trajektorien schliessen */ fprintf(state->fh, "</Folder>\n\n"); free(plot_field); }
// set new search and replace patterns template<class T>void operator ()(const regexp ®ex, const T &replacestring = std::string()) { reset_counter(); this->regex = regex; this->replacestring.assign(replacestring); }