feat: bunching effect

src-tauri/src/bunching.rs

@@ -0,0 +1,73 @@
+use crate::range::*;
+use postflop_solver::*;
+use rayon::ThreadPool;
+use std::sync::Mutex;
+
+#[tauri::command]
+pub fn bunching_init(
+    range_state: tauri::State<Mutex<RangeManager>>,
+    bunching_state: tauri::State<Mutex<Option<BunchingData>>>,
+    board: Vec<u8>,
+) -> Option<String> {
+    if board.len() < 3 {
+        return Some("Board must have at least 3 cards".to_string());
+    }
+
+    let ranges = &range_state.lock().unwrap().0;
+    let bunching_data = BunchingData::new(&ranges[2..], board[..3].try_into().unwrap());
+
+    match bunching_data {
+        Ok(bunching_data) => {
+            *bunching_state.lock().unwrap() = Some(bunching_data);
+            None
+        }
+        Err(e) => Some(e),
+    }
+}
+
+#[tauri::command]
+pub fn bunching_clear(bunching_state: tauri::State<Mutex<Option<BunchingData>>>) {
+    *bunching_state.lock().unwrap() = None;
+}
+
+#[tauri::command(async)]
+pub fn bunching_progress(
+    bunching_state: tauri::State<Mutex<Option<BunchingData>>>,
+    pool_state: tauri::State<Mutex<ThreadPool>>,
+) -> [u8; 2] {
+    let mut bunching_data = bunching_state.lock().unwrap();
+    let bunching_data = bunching_data.as_mut().unwrap();
+    let pool = pool_state.lock().unwrap();
+
+    let phase = bunching_data.phase();
+    let percent = bunching_data.progress_percent();
+    if phase == 3 && percent == 100 {
+        return [3, 100];
+    }
+
+    pool.install(|| {
+        if phase == 0 {
+            bunching_data.phase1_prepare();
+        } else if phase == 1 {
+            if percent < 100 {
+                bunching_data.phase1_proceed_by_percent();
+            } else {
+                bunching_data.phase2_prepare();
+            }
+        } else if phase == 2 {
+            if percent < 100 {
+                bunching_data.phase2_proceed_by_percent();
+            } else {
+                bunching_data.phase3_prepare();
+            }
+        } else if phase == 3 {
+            bunching_data.phase3_proceed_by_percent();
+        }
+    });
+
+    if phase == 0 || percent == 100 {
+        [phase + 1, 0]
+    } else {
+        [phase, percent + 1]
+    }
+}

src-tauri/src/main.rs

@@ -3,27 +3,34 @@
     windows_subsystem = "windows"
 )]
 
+mod bunching;
 mod range;
 mod solver;
 mod tree;
+use crate::bunching::*;
 use crate::range::*;
 use crate::solver::*;
 use crate::tree::*;
 
 use postflop_solver::*;
+use rayon::{ThreadPool, ThreadPoolBuilder};
 use std::sync::Mutex;
 use sysinfo::{System, SystemExt};
 
 fn main() {
     tauri::Builder::default()
         .manage(Mutex::new(RangeManager::default()))
         .manage(Mutex::new(default_action_tree()))
+        .manage(Mutex::new(None as Option<BunchingData>))
         .manage(Mutex::new(PostFlopGame::default()))
-        .manage(Mutex::new(default_thread_pool()))
+        .manage(Mutex::new(ThreadPoolBuilder::new().build().unwrap()))
         .invoke_handler(tauri::generate_handler![
             os_name,
             memory,
+            set_num_threads,
+            range_num_combos,
             range_clear,
+            range_invert,
             range_update,
             range_from_string,
             range_to_string,
@@ -44,10 +51,15 @@ fn main() {
             tree_remove_current_node,
             tree_delete_added_line,
             tree_delete_removed_line,
+            bunching_init,
+            bunching_clear,
+            bunching_progress,
             game_init,
             game_private_cards,
             game_memory_usage,
+            game_memory_usage_bunching,
             game_allocate_memory,
+            game_set_bunching,
             game_solve_step,
             game_exploitability,
             game_finalize,
@@ -86,3 +98,11 @@ fn memory() -> (u64, u64) {
     system.refresh_memory();
     (system.available_memory(), system.total_memory())
 }
+
+#[tauri::command]
+fn set_num_threads(pool_state: tauri::State<Mutex<ThreadPool>>, num_threads: usize) {
+    *pool_state.lock().unwrap() = ThreadPoolBuilder::new()
+        .num_threads(num_threads)
+        .build()
+        .unwrap();
+}

src-tauri/src/range.rs

@@ -3,14 +3,26 @@ use std::cmp::Ordering;
 use std::sync::Mutex;
 
 #[derive(Default)]
-pub struct RangeManager(pub [Range; 2]);
+pub struct RangeManager(pub [Range; 6]);
+
+#[tauri::command]
+pub fn range_num_combos(range_state: tauri::State<Mutex<RangeManager>>, player: usize) -> f64 {
+    let range = &(range_state.lock().unwrap().0)[player];
+    range.raw_data().iter().fold(0.0, |acc, &x| acc + x as f64)
+}
 
 #[tauri::command]
 pub fn range_clear(range_state: tauri::State<Mutex<RangeManager>>, player: usize) {
     let range = &mut (range_state.lock().unwrap().0)[player];
     range.clear();
 }
 
+#[tauri::command]
+pub fn range_invert(range_state: tauri::State<Mutex<RangeManager>>, player: usize) {
+    let range = &mut (range_state.lock().unwrap().0)[player];
+    range.invert();
+}
+
 #[tauri::command]
 pub fn range_update(
     range_state: tauri::State<Mutex<RangeManager>>,

src-tauri/src/solver.rs

@@ -1,13 +1,9 @@
 use crate::range::*;
 use postflop_solver::*;
-use rayon::{ThreadPool, ThreadPoolBuilder};
+use rayon::ThreadPool;
 use serde::Serialize;
 use std::sync::Mutex;
 
-pub fn default_thread_pool() -> ThreadPool {
-    ThreadPoolBuilder::new().build().unwrap()
-}
-
 #[inline]
 fn decode_action(action: &str) -> Action {
     match action {
@@ -73,8 +69,6 @@ pub fn weighted_average(slice: &[f32], weights: &[f32]) -> f64 {
 pub fn game_init(
     range_state: tauri::State<Mutex<RangeManager>>,
     game_state: tauri::State<Mutex<PostFlopGame>>,
-    pool_state: tauri::State<Mutex<ThreadPool>>,
-    num_threads: usize,
     board: Vec<u8>,
     starting_pot: i32,
     effective_stack: i32,
@@ -101,12 +95,6 @@ pub fn game_init(
     added_lines: String,
     removed_lines: String,
 ) -> Option<String> {
-    let mut pool = pool_state.lock().unwrap();
-    *pool = ThreadPoolBuilder::new()
-        .num_threads(num_threads)
-        .build()
-        .unwrap();
-
     let (turn, river, state) = match board.len() {
         3 => (NOT_DEALT, NOT_DEALT, BoardState::Flop),
         4 => (board[3], NOT_DEALT, BoardState::Turn),
@@ -116,7 +104,7 @@ pub fn game_init(
 
     let ranges = &range_state.lock().unwrap().0;
     let card_config = CardConfig {
-        range: *ranges,
+        range: ranges[..2].try_into().unwrap(),
         flop: board[..3].try_into().unwrap(),
         turn,
         river,
@@ -202,6 +190,12 @@ pub fn game_memory_usage(game_state: tauri::State<Mutex<PostFlopGame>>) -> (u64,
     game.memory_usage()
 }
 
+#[tauri::command]
+pub fn game_memory_usage_bunching(game_state: tauri::State<Mutex<PostFlopGame>>) -> u64 {
+    let game = game_state.lock().unwrap();
+    game.memory_usage_bunching()
+}
+
 #[tauri::command(async)]
 pub fn game_allocate_memory(
     game_state: tauri::State<Mutex<PostFlopGame>>,
@@ -211,6 +205,17 @@ pub fn game_allocate_memory(
     game.allocate_memory(enable_compression);
 }
 
+#[tauri::command(async)]
+pub fn game_set_bunching(
+    bunching_state: tauri::State<Mutex<Option<BunchingData>>>,
+    game_state: tauri::State<Mutex<PostFlopGame>>,
+) {
+    let bunching_data = bunching_state.lock().unwrap();
+    let bunching_data = bunching_data.as_ref().unwrap();
+    let mut game = game_state.lock().unwrap();
+    game.set_bunching_effect(bunching_data).unwrap();
+}
+
 #[tauri::command(async)]
 pub fn game_solve_step(
     game_state: tauri::State<Mutex<PostFlopGame>>,

src/components/App.vue

@@ -36,6 +36,9 @@
         <div v-show="store.sideView === 'tree-config'">
           <TreeConfig />
         </div>
+        <div v-show="store.sideView === 'bunching'">
+          <BunchingEffect />
+        </div>
         <div v-show="store.sideView === 'run-solver'">
           <RunSolver />
         </div>
@@ -63,22 +66,13 @@ import SideBar from "./SideBar.vue";
 import RangeEditor from "./RangeEditor.vue";
 import BoardSelector from "./BoardSelector.vue";
 import TreeConfig from "./TreeConfig.vue";
+import BunchingEffect from "./BunchingEffect.vue";
 import RunSolver from "./RunSolver.vue";
 import AboutPage from "./AboutPage.vue";
 import ResultViewer from "./ResultViewer.vue";
 
 const store = useStore();
-const header = computed(
-  () =>
-    ({
-      about: "About",
-      "oop-range": "OOP Range",
-      "ip-range": "IP Range",
-      board: "Board",
-      "tree-config": "Tree Configuration",
-      "run-solver": "Run Solver",
-    }[store.sideView])
-);
+const header = computed(() => store.headers[store.sideView].join(" > "));
 
 const clientHeight = ref(0);
 const updateClientHeight = () => {

src/components/BoardSelector.vue

@@ -25,7 +25,7 @@
       config.expectedBoardLength > 0 &&
       config.board.length !== config.expectedBoardLength
     "
-    class="mt-5 font-semibold text-orange-500"
+    class="mt-5 text-orange-500 font-semibold"
   >
     <span class="underline">Warning:</span>
     The edited tree assumes a {{ config.expectedBoardLength }}-card board.
@@ -43,7 +43,9 @@ const toggleCard = (cardId: number) => {
     config.board = config.board.filter((card) => card !== cardId);
   } else if (config.board.length < 5) {
     config.board.push(cardId);
-    config.board.sort((a, b) => b - a);
+    if (config.board.length <= 3) {
+      config.board.sort((a, b) => b - a);
+    }
   }
 };