ref: accept thor param on the thor trait

panstromek · panstromek · commit cc3b525d8cd8 · 2025-02-09T16:39:25.000+01:00
diff --git a/crates/engine/src/game.rs b/crates/engine/src/game.rs
@@ -1011,12 +1011,12 @@ pub fn generic_compute_move<L: ComputeMoveLogger, Out: ComputeMoveOutput, FE: Fr
     if book_move_found == 0 && play_thor_match_openings != 0 {
         /* Optionally use the Thor database as opening book. */
         let threshold = 2;
-        Thor::database_search(&g_state.board.board, side_to_move);
-        if Thor::get_match_count() >= threshold {
+        Thor::database_search(thor, &g_state.board.board, side_to_move);
+        if Thor::get_match_count(thor) >= threshold {
             let game_index =
                 ((g_state.random.my_random() >> 8) %
-                    Thor::get_match_count() as i64) as i32;
-            curr_move = Thor::get_thor_game_move(game_index, g_state.moves.disks_played) as i8;
+                    Thor::get_match_count(thor) as i64) as i32;
+            curr_move = Thor::get_thor_game_move(thor, game_index, g_state.moves.disks_played) as i8;
             if valid_move(curr_move, side_to_move, &g_state.board.board) != 0 {
                 book_eval_info =
                     create_eval_info(UNDEFINED_EVAL, UNSOLVED_POSITION,
@@ -1041,7 +1041,7 @@ pub fn generic_compute_move<L: ComputeMoveLogger, Out: ComputeMoveOutput, FE: Fr
     if book_move_found == 0 && g_state.game.play_human_openings != 0 && book != 0 {
         /* Check Thor statistics for a move */
         curr_move =
-            Thor::choose_thor_opening_move(&g_state.board.board, side_to_move,
+            Thor::choose_thor_opening_move(thor, &g_state.board.board, side_to_move,
                                            0, &mut g_state.random) as i8;
         if curr_move != -(1) {
             book_eval_info =
diff --git a/crates/engine/src/thordb.rs b/crates/engine/src/thordb.rs
@@ -1,13 +1,13 @@
 use crate::src::myrandom::MyRandom;
 
 pub trait ThorDatabase {
-    fn get_thor_game_move(index: i32, move_number: i32) -> i32;
-    fn database_search(in_board: &[i32], side_to_move: i32);
-    fn get_match_count() -> i32;
-    fn get_black_win_count() -> i32;
-    fn get_draw_count() -> i32;
-    fn get_white_win_count() -> i32;
-    fn get_black_median_score() -> i32;
-    fn get_black_average_score() -> f64;
-    fn choose_thor_opening_move(in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32;
+    fn get_thor_game_move(&self, index: i32, move_number: i32) -> i32;
+    fn database_search(&self, in_board: &[i32], side_to_move: i32);
+    fn get_match_count(&self) -> i32;
+    fn get_black_win_count(&self) -> i32;
+    fn get_draw_count(&self) -> i32;
+    fn get_white_win_count(&self) -> i32;
+    fn get_black_median_score(&self) -> i32;
+    fn get_black_average_score(&self) -> f64;
+    fn choose_thor_opening_move(&self, in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32;
 }
diff --git a/crates/legacy-zebra/src/thordb.rs b/crates/legacy-zebra/src/thordb.rs
@@ -118,39 +118,39 @@ static mut filter: FilterType =
 pub struct LegacyThor;
 
 impl ThorDatabase for LegacyThor {
-    fn get_thor_game_move(index: i32, move_number: i32) -> i32 {
+    fn get_thor_game_move(&self, index: i32, move_number: i32) -> i32 {
         unsafe { get_thor_game_move(index, move_number) }
     }
 
-    fn database_search(in_board: &[i32], side_to_move: i32) {
+    fn database_search(&self, in_board: &[i32], side_to_move: i32) {
         unsafe { database_search(in_board, side_to_move) }
     }
 
-    fn get_match_count() -> i32 {
+    fn get_match_count(&self) -> i32 {
         unsafe { thor_search.get_match_count() }
     }
 
-    fn get_black_win_count() -> i32 {
+    fn get_black_win_count(&self) -> i32 {
         unsafe { thor_search.get_black_win_count() }
     }
 
-    fn get_draw_count() -> i32 {
+    fn get_draw_count(&self) -> i32 {
         unsafe { thor_search.get_draw_count() }
     }
 
-    fn get_white_win_count() -> i32 {
+    fn get_white_win_count(&self) -> i32 {
         unsafe { thor_search.get_white_win_count() }
     }
 
-    fn get_black_median_score() -> i32 {
+    fn get_black_median_score(&self) -> i32 {
         unsafe { thor_search.get_black_median_score() }
     }
 
-    fn get_black_average_score() -> f64 {
+    fn get_black_average_score(&self) -> f64 {
         unsafe { thor_search.get_black_average_score() }
     }
 
-    fn choose_thor_opening_move(in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {
+    fn choose_thor_opening_move(&self, in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {
         unsafe { choose_thor_opening_move(in_board, side_to_move, echo, random) }
     }
 }
diff --git a/crates/legacy-zebra/src/zebra.rs b/crates/legacy-zebra/src/zebra.rs
@@ -747,7 +747,7 @@ fn play_game(mut file_name: &str,
     type ComputeMoveOut = LibcZebraOutput;
     type Learn = LibcLearner;
     type FE = LibcFatalError;
-    type Thor = LegacyThor;
+    let thor = LegacyThor;
     let mut play_state: PlayGame<Source> = PlayGame::new(file_name, move_string, repeat, move_file, g_state);
     let mut move_attempt = None;
     let mut total_search_time: f64 = 0.;
@@ -756,7 +756,7 @@ fn play_game(mut file_name: &str,
     let mut stdin_lock = stdin.lock();
     loop {
         let state = next_state::<
-            ZF, Source, BoardSrc, ComputeMoveLog, ComputeMoveOut, FE, Thor
+            ZF, Source, BoardSrc, ComputeMoveLog, ComputeMoveOut, FE, LegacyThor
         >(&mut play_state, move_attempt.take(), &LegacyThor);
         match state {
             // TODO here in all these branches, we should ideally not need mutable reference to play_state
@@ -799,7 +799,7 @@ fn play_game(mut file_name: &str,
                 dump_position(play_state.side_to_move, &play_state.g_state.board.board);
                 dump_game_score(play_state.side_to_move, play_state.g_state.board.score_sheet_row, &play_state.g_state.board.black_moves, &play_state.g_state.board.white_moves);
                 /* Check what the Thor opening statistics has to say */
-                Thor::choose_thor_opening_move(&play_state.g_state.board.board, play_state.side_to_move, play_state.g_state.config.echo, &mut play_state.g_state.random);
+                thor.choose_thor_opening_move(&play_state.g_state.board.board, play_state.side_to_move, play_state.g_state.config.echo, &mut play_state.g_state.random);
             }
             PlayGameState::CanLearn => {
                 if play_state.g_state.config.use_learning && play_state.g_state.config.one_position_only == 0 {
@@ -852,22 +852,22 @@ fn deal_with_thor_1(use_thor_: bool, side_to_move: i32,
                                                            mut config: &Config, g_timer: &Timer,
                                                            board_state: &BoardState, total_search_time: &mut f64) {
     type ZF = LibcFrontend;
-    type Thor = LegacyThor;
+    let thor = LegacyThor;
 
     if use_thor_ {
         let database_start = g_timer.get_real_timer();
-        Thor::database_search(&board_state.board, side_to_move);
-        let thor_position_count = Thor::get_match_count();
+        thor.database_search(&board_state.board, side_to_move);
+        let thor_position_count = thor.get_match_count();
         let database_stop = g_timer.get_real_timer();
         let database_time = database_stop - database_start;
         *total_search_time += database_time;
         ZF::report_thor_matching_games_stats(*total_search_time, thor_position_count, database_time);
         if thor_position_count > 0 {
-            let black_win_count = Thor::get_black_win_count();
-            let draw_count = Thor::get_draw_count();
-            let white_win_count = Thor::get_white_win_count();
-            let black_median_score = Thor::get_black_median_score();
-            let black_average_score = Thor::get_black_average_score();
+            let black_win_count = thor.get_black_win_count();
+            let draw_count = thor.get_draw_count();
+            let white_win_count = thor.get_white_win_count();
+            let black_median_score = thor.get_black_median_score();
+            let black_average_score = thor.get_black_average_score();
 
             ZF::report_thor_stats(black_win_count, draw_count, white_win_count, black_median_score, black_average_score);
         }
@@ -879,21 +879,22 @@ fn deal_with_thor_2(use_thor_: bool, side_to_move: i32,
                                                           config: &Config, g_timer: &Timer,
                                                           board_state: &BoardState, total_search_time: &mut f64){
     type ZF = LibcFrontend;
-    type Thor = LegacyThor;
+    let thor = LegacyThor{};
+    use ThorDatabase;
     if use_thor_ {
         let database_start = g_timer.get_real_timer();
-        Thor::database_search(&board_state.board, side_to_move);
-        let thor_position_count = Thor::get_match_count();
+        thor.database_search(&board_state.board, side_to_move);
+        let thor_position_count = thor.get_match_count();
         let database_stop = g_timer.get_real_timer();
         let db_search_time = database_stop - database_start;
         *total_search_time += db_search_time;
         ZF::report_some_thor_stats(*total_search_time, thor_position_count, db_search_time);
         if thor_position_count > 0 {
-            let black_win_count = Thor::get_black_win_count();
-            let draw_count = Thor::get_draw_count();
-            let white_win_count = Thor::get_white_win_count();
-            let black_median_score = Thor::get_black_median_score();
-            let black_average_score = Thor::get_black_average_score();
+            let black_win_count = thor.get_black_win_count();
+            let draw_count = thor.get_draw_count();
+            let white_win_count = thor.get_white_win_count();
+            let black_median_score = thor.get_black_median_score();
+            let black_average_score = thor.get_black_average_score();
             ZF::report_some_thor_scores(black_win_count, draw_count, white_win_count, black_median_score, black_average_score);
         }
         ZF::print_out_thor_matches(config.thor_max_games);
diff --git a/webzebra/crate/src/lib.rs b/webzebra/crate/src/lib.rs
@@ -468,40 +468,40 @@ pub enum InteractionRequest {
 struct WasmThor;
 
 impl ThorDatabase for WasmThor {
-    fn get_thor_game_move(index: i32, move_number: i32) -> i32 {
+    fn get_thor_game_move(&self, index: i32, move_number: i32) -> i32 {
         0
     }
 
-    fn database_search(in_board: &[i32], side_to_move: i32) {
+    fn database_search(&self, in_board: &[i32], side_to_move: i32) {
         //
     }
 
-    fn get_match_count() -> i32 {
+    fn get_match_count(&self) -> i32 {
         //
         0
     }
 
-    fn get_black_win_count() -> i32 {
+    fn get_black_win_count(&self) -> i32 {
         0
     }
 
-    fn get_draw_count() -> i32 {
+    fn get_draw_count(&self) -> i32 {
         0
     }
 
-    fn get_white_win_count() -> i32 {
+    fn get_white_win_count(&self) -> i32 {
         0
     }
 
-    fn get_black_median_score() -> i32 {
+    fn get_black_median_score(&self) -> i32 {
         0
     }
 
-    fn get_black_average_score() -> f64 {
+    fn get_black_average_score(&self) -> f64 {
         0.0
     }
 
-    fn choose_thor_opening_move(in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {
+    fn choose_thor_opening_move(&self, in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {
         0
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -118,39 +118,39 @@ static mut filter: FilterType =`
`118`	`118`	`pub struct LegacyThor;`
`119`	`119`
`120`	`120`	`impl ThorDatabase for LegacyThor {`
`121`		`- fn get_thor_game_move(index: i32, move_number: i32) -> i32 {`
	`121`	`+ fn get_thor_game_move(&self, index: i32, move_number: i32) -> i32 {`
`122`	`122`	`unsafe { get_thor_game_move(index, move_number) }`
`123`	`123`	`}`
`124`	`124`
`125`		`- fn database_search(in_board: &[i32], side_to_move: i32) {`
	`125`	`+ fn database_search(&self, in_board: &[i32], side_to_move: i32) {`
`126`	`126`	`unsafe { database_search(in_board, side_to_move) }`
`127`	`127`	`}`
`128`	`128`
`129`		`- fn get_match_count() -> i32 {`
	`129`	`+ fn get_match_count(&self) -> i32 {`
`130`	`130`	`unsafe { thor_search.get_match_count() }`
`131`	`131`	`}`
`132`	`132`
`133`		`- fn get_black_win_count() -> i32 {`
	`133`	`+ fn get_black_win_count(&self) -> i32 {`
`134`	`134`	`unsafe { thor_search.get_black_win_count() }`
`135`	`135`	`}`
`136`	`136`
`137`		`- fn get_draw_count() -> i32 {`
	`137`	`+ fn get_draw_count(&self) -> i32 {`
`138`	`138`	`unsafe { thor_search.get_draw_count() }`
`139`	`139`	`}`
`140`	`140`
`141`		`- fn get_white_win_count() -> i32 {`
	`141`	`+ fn get_white_win_count(&self) -> i32 {`
`142`	`142`	`unsafe { thor_search.get_white_win_count() }`
`143`	`143`	`}`
`144`	`144`
`145`		`- fn get_black_median_score() -> i32 {`
	`145`	`+ fn get_black_median_score(&self) -> i32 {`
`146`	`146`	`unsafe { thor_search.get_black_median_score() }`
`147`	`147`	`}`
`148`	`148`
`149`		`- fn get_black_average_score() -> f64 {`
	`149`	`+ fn get_black_average_score(&self) -> f64 {`
`150`	`150`	`unsafe { thor_search.get_black_average_score() }`
`151`	`151`	`}`
`152`	`152`
`153`		`- fn choose_thor_opening_move(in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {`
	`153`	`+ fn choose_thor_opening_move(&self, in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {`
`154`	`154`	`unsafe { choose_thor_opening_move(in_board, side_to_move, echo, random) }`
`155`	`155`	`}`
`156`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -468,40 +468,40 @@ pub enum InteractionRequest {`
`468`	`468`	`struct WasmThor;`
`469`	`469`
`470`	`470`	`impl ThorDatabase for WasmThor {`
`471`		`- fn get_thor_game_move(index: i32, move_number: i32) -> i32 {`
	`471`	`+ fn get_thor_game_move(&self, index: i32, move_number: i32) -> i32 {`
`472`	`472`	`0`
`473`	`473`	`}`
`474`	`474`
`475`		`- fn database_search(in_board: &[i32], side_to_move: i32) {`
	`475`	`+ fn database_search(&self, in_board: &[i32], side_to_move: i32) {`
`476`	`476`	`//`
`477`	`477`	`}`
`478`	`478`
`479`		`- fn get_match_count() -> i32 {`
	`479`	`+ fn get_match_count(&self) -> i32 {`
`480`	`480`	`//`
`481`	`481`	`0`
`482`	`482`	`}`
`483`	`483`
`484`		`- fn get_black_win_count() -> i32 {`
	`484`	`+ fn get_black_win_count(&self) -> i32 {`
`485`	`485`	`0`
`486`	`486`	`}`
`487`	`487`
`488`		`- fn get_draw_count() -> i32 {`
	`488`	`+ fn get_draw_count(&self) -> i32 {`
`489`	`489`	`0`
`490`	`490`	`}`
`491`	`491`
`492`		`- fn get_white_win_count() -> i32 {`
	`492`	`+ fn get_white_win_count(&self) -> i32 {`
`493`	`493`	`0`
`494`	`494`	`}`
`495`	`495`
`496`		`- fn get_black_median_score() -> i32 {`
	`496`	`+ fn get_black_median_score(&self) -> i32 {`
`497`	`497`	`0`
`498`	`498`	`}`
`499`	`499`
`500`		`- fn get_black_average_score() -> f64 {`
	`500`	`+ fn get_black_average_score(&self) -> f64 {`
`501`	`501`	`0.0`
`502`	`502`	`}`
`503`	`503`
`504`		`- fn choose_thor_opening_move(in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {`
	`504`	`+ fn choose_thor_opening_move(&self, in_board: &[i32], side_to_move: i32, echo: i32, random: &mut MyRandom) -> i32 {`
`505`	`505`	`0`
`506`	`506`	`}`
`507`	`507`	`}`