Add some preload examples.

Author: willwang-io

assets/style.css

@@ -148,3 +148,10 @@
 .piece-toggle.selected {
   border: 1px solid rgba(34, 34, 34, 0.6);
 }
+
+.preset-buttons {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin: 8px 0 16px;
+}

src/board.rs

@@ -60,7 +60,9 @@ impl Board {
 
     pub fn single_is_king(&self) -> bool {
         let mut it = self.pieces();
-        let Some((_, _, p)) = it.next() else { return false; };
+        let Some((_, _, p)) = it.next() else {
+            return false;
+        };
         it.next().is_none() && p.is_king()
     }
 }

src/main.rs

@@ -62,6 +62,25 @@ fn App() -> Element {
         document::Link { rel: "stylesheet", href: STYLE }
         main {
             h1 { "Solo-Chess Solver" }
+            section {
+                div {
+                    class: "preset-buttons",
+                    for setup in EXAMPLE_SETUPS {
+                        button {
+                            key: "{setup.name}",
+                            class: "preset-button",
+                            r#type: "button",
+                            onclick: {
+                                let board_state = board_state;
+                                let selected_step = selected_step;
+                                let pieces = setup.pieces;
+                                move |_| apply_preset(board_state, selected_step, pieces)
+                            },
+                            "{setup.name}"
+                        }
+                    }
+                }
+            }
             div {
                 class: "board-stack",
                 Chessboard {
@@ -88,3 +107,58 @@ fn App() -> Element {
         }
     }
 }
+
+struct ExampleSetup {
+    name: &'static str,
+    pieces: &'static [(usize, usize, PieceType)],
+}
+
+const EXAMPLE_SETUPS: &[ExampleSetup] = &[
+    ExampleSetup {
+        name: "Clear",
+        pieces: &[],
+    },
+    ExampleSetup {
+        name: "Easy Example",
+        pieces: &[
+            (0, 5, PieceType::Rook),
+            (2, 4, PieceType::Bishop),
+            (3, 2, PieceType::Rook),
+            (3, 5, PieceType::Queen),
+        ],
+    },
+    ExampleSetup {
+        name: "Hard Example",
+        pieces: &[
+            (0, 1, PieceType::Rook),
+            (0, 3, PieceType::Knight),
+            (1, 0, PieceType::King),
+            (1, 1, PieceType::Rook),
+            (2, 2, PieceType::Knight),
+            (2, 3, PieceType::Knight),
+            (3, 0, PieceType::Bishop),
+            (4, 0, PieceType::Knight),
+            (1, 6, PieceType::Queen),
+            (7, 1, PieceType::Rook),
+            (3, 2, PieceType::Knight),
+        ],
+    },
+];
+
+fn apply_preset(
+    mut board_state: Signal<Board>,
+    mut selected_step: Signal<Option<usize>>,
+    pieces: &[(usize, usize, PieceType)],
+) {
+    board_state.with_mut(|b| {
+        for r in 0..8 {
+            for c in 0..8 {
+                b.clear_cell(r, c);
+            }
+        }
+        for &(r, c, piece_type) in pieces {
+            b.set_cell(r, c, Piece::new(piece_type));
+        }
+    });
+    selected_step.set(None);
+}

src/solver.rs

@@ -42,7 +42,11 @@ pub fn solo_chess_solver(board: &mut Board) -> Vec<Step> {
         let p = board.count_pieces();
 
         if p <= 1 {
-            return if king_required { board.single_is_king() } else { p == 1 };
+            return if king_required {
+                board.single_is_king()
+            } else {
+                p == 1
+            };
         }
 
         if board.sum_move_left() < p - 1 {
@@ -127,7 +131,7 @@ fn get_capturable_cells_into(
     c: usize,
     piece_type: PieceType,
     move_rules: &[(i32, i32)],
-    out: &mut Vec<Step>
+    out: &mut Vec<Step>,
 ) {
     let is_king = piece_type == PieceType::King;
     let is_pawn = piece_type == PieceType::Pawn;
@@ -310,7 +314,7 @@ mod test_utilities {
         list_capture_pairs_into(&board, &mut capture_pairs);
         assert!(capture_pairs.is_empty());
 
-        // The check on that direction should stop if met a King. 
+        // The check on that direction should stop if met a King.
         board.set_cell(5, 0, Piece::new(PieceType::Pawn));
         board.set_cell(5, 2, Piece::new(PieceType::King));
         list_capture_pairs_into(&board, &mut capture_pairs);
@@ -401,4 +405,4 @@ mod test_utilities {
         }
         assert_eq!(ca, cb);
     }
-}
+}

src/ui/solution.rs

@@ -28,12 +28,21 @@ pub fn Solution(steps: Vec<Step>, selected_step: Signal<Option<usize>>) -> Eleme
 fn to_sans(steps: &[Step]) -> Vec<String> {
     let mut sans_step = vec![];
 
-    let numeric_to_sans = |r: usize, c: usize| -> String {
-        format!("{}{}", (c as u8 + b'a') as char, 8 - r)
-    };
+    let numeric_to_sans =
+        |r: usize, c: usize| -> String { format!("{}{}", (c as u8 + b'a') as char, 8 - r) };
 
-    for Step { from: (fr, fc), to: (tr, tc), piece_type } in steps {
-        let tmp = format!("{}{}x{}", piece_type.to_string(), numeric_to_sans(*fr, *fc), numeric_to_sans(*tr, *tc));
+    for Step {
+        from: (fr, fc),
+        to: (tr, tc),
+        piece_type,
+    } in steps
+    {
+        let tmp = format!(
+            "{}{}x{}",
+            piece_type.to_string(),
+            numeric_to_sans(*fr, *fc),
+            numeric_to_sans(*tr, *tc)
+        );
         sans_step.push(tmp);
     }
     sans_step

src/ui/step_colors.rs

@@ -1,12 +1,4 @@
 pub const STEP_COLORS: [&str; 10] = [
-    "#e6194b",
-    "#f58231",
-    "#ffe119",
-    "#3cb44b",
-    "#42d4f4",
-    "#4363d8",
-    "#911eb4",
-    "#f032e6",
-    "#bfef45",
-    "#fabebe",
+    "#e6194b", "#f58231", "#ffe119", "#3cb44b", "#42d4f4", "#4363d8", "#911eb4", "#f032e6",
+    "#bfef45", "#fabebe",
 ];