v3.2.0: straight and split bets anywhere on the felt; add history command

1 files changed, 72 insertions, 25 deletions

diff --git a/tests/roulette.rs b/tests/roulette.rs
index 8f9155c..0c5e195 100644
--- a/tests/roulette.rs
+++ b/tests/roulette.rs
@@ -234,28 +234,51 @@ fn target_at(x: usize, y: usize) -> BetTarget {
 }
 
 #[test]
-fn lattice_points_become_straights_splits_and_corners() {
-    assert_eq!(
-        target_at(0, 3),
-        BetTarget::Straight { number: 1 },
-        "bottom-left corner is a straight"
-    );
-    assert_eq!(target_at(0, 0), BetTarget::Straight { number: 3 });
-    assert_eq!(target_at(12, 0), BetTarget::Straight { number: 36 });
-    assert_eq!(target_at(12, 3), BetTarget::Straight { number: 34 });
-
-    assert_eq!(target_at(0, 1), BetTarget::Split { a: 2, b: 3 });
-    assert_eq!(target_at(12, 1), BetTarget::Split { a: 35, b: 36 });
-    assert_eq!(target_at(1, 0), BetTarget::Split { a: 3, b: 6 });
+fn cell_centres_are_straights() {
+    assert_eq!(target_at(1, 5), BetTarget::Straight { number: 1 });
+    assert_eq!(target_at(1, 1), BetTarget::Straight { number: 3 });
+    assert_eq!(target_at(23, 1), BetTarget::Straight { number: 36 });
+    assert_eq!(target_at(23, 5), BetTarget::Straight { number: 34 });
+    assert_eq!(target_at(5, 3), BetTarget::Straight { number: 8 });
+
+    // Every one of the 36 numbers can be bet straight.
+    let mut reachable = Vec::new();
+    for column in 0..12usize {
+        for row in 0..3usize {
+            let cursor = Cursor::Lattice {
+                x: 2 * column + 1,
+                y: 2 * row + 1,
+            };
+            if let Some(BetTarget::Straight { number }) = cursor.target() {
+                reachable.push(number);
+            }
+        }
+    }
+    reachable.sort_unstable();
+    assert_eq!(reachable, (1..=36).collect::<Vec<_>>());
+}
 
+#[test]
+fn lines_between_cells_are_splits_and_crossings_are_corners() {
+    // Vertical lines sit between two columns.
+    assert_eq!(target_at(2, 5), BetTarget::Split { a: 1, b: 4 });
+    assert_eq!(target_at(2, 3), BetTarget::Split { a: 2, b: 5 });
+    assert_eq!(target_at(22, 1), BetTarget::Split { a: 33, b: 36 });
+
+    // Horizontal lines sit between two rows.
+    assert_eq!(target_at(1, 4), BetTarget::Split { a: 1, b: 2 });
+    assert_eq!(target_at(3, 2), BetTarget::Split { a: 5, b: 6 });
+    assert_eq!(target_at(23, 4), BetTarget::Split { a: 34, b: 35 });
+
+    // Crossings cover four cells.
     assert_eq!(
-        target_at(1, 1),
+        target_at(2, 4),
         BetTarget::Corner {
-            numbers: [2, 3, 5, 6]
+            numbers: [1, 2, 4, 5]
         }
     );
     assert_eq!(
-        target_at(6, 2),
+        target_at(12, 4),
         BetTarget::Corner {
             numbers: [16, 17, 19, 20]
         }
@@ -264,31 +287,54 @@ fn lattice_points_become_straights_splits_and_corners() {
 
 #[test]
 fn the_cursor_walks_the_felt_and_the_outside_rows() {
-    let bottom = Cursor::Lattice { x: 0, y: 3 };
+    let bottom = Cursor::Lattice { x: 1, y: 5 };
+    // One step right is the split between 1 and 4, two steps is number 4.
+    assert_eq!(
+        bottom.moved(Direction::Right),
+        Cursor::Lattice { x: 2, y: 5 }
+    );
+    assert_eq!(
+        bottom.moved(Direction::Right).moved(Direction::Right),
+        Cursor::Lattice { x: 3, y: 5 }
+    );
+    // One step up is the split between 1 and 2.
+    assert_eq!(bottom.moved(Direction::Up), Cursor::Lattice { x: 1, y: 4 });
+
     assert_eq!(bottom.moved(Direction::Down), Cursor::Dozen(0));
     assert_eq!(
-        Cursor::Lattice { x: 12, y: 3 }.moved(Direction::Down),
+        Cursor::Lattice { x: 23, y: 5 }.moved(Direction::Down),
         Cursor::Dozen(2)
     );
     assert_eq!(
-        Cursor::Lattice { x: 0, y: 0 }.moved(Direction::Up),
+        Cursor::Lattice { x: 1, y: 1 }.moved(Direction::Up),
         Cursor::Zero
     );
-    assert_eq!(Cursor::Zero.moved(Direction::Down), Cursor::Lattice { x: 0, y: 0 });
+    assert_eq!(
+        Cursor::Zero.moved(Direction::Down),
+        Cursor::Lattice { x: 1, y: 1 }
+    );
 
-    assert_eq!(Cursor::Dozen(0).moved(Direction::Up), Cursor::Lattice { x: 1, y: 3 });
+    assert_eq!(
+        Cursor::Dozen(0).moved(Direction::Up),
+        Cursor::Lattice { x: 1, y: 5 }
+    );
     assert_eq!(Cursor::Dozen(0).moved(Direction::Down), Cursor::Column(0));
+    assert_eq!(Cursor::Dozen(2).moved(Direction::Up), Cursor::Lattice { x: 17, y: 5 });
     assert_eq!(Cursor::Column(2).moved(Direction::Up), Cursor::Dozen(2));
     assert_eq!(Cursor::Column(1).moved(Direction::Down), Cursor::Outside(2));
     assert_eq!(Cursor::Outside(3).moved(Direction::Up), Cursor::Column(1));
 
     // Edges stay put instead of wrapping.
-    assert_eq!(Cursor::Dozen(0).moved(Direction::Left), Cursor::Dozen(0));
-    assert_eq!(Cursor::Outside(5).moved(Direction::Right), Cursor::Outside(5));
     assert_eq!(
-        Cursor::Lattice { x: 0, y: 2 }.moved(Direction::Left),
-        Cursor::Lattice { x: 0, y: 2 }
+        Cursor::Lattice { x: 1, y: 3 }.moved(Direction::Left),
+        Cursor::Lattice { x: 1, y: 3 }
+    );
+    assert_eq!(
+        Cursor::Lattice { x: 23, y: 3 }.moved(Direction::Right),
+        Cursor::Lattice { x: 23, y: 3 }
     );
+    assert_eq!(Cursor::Dozen(0).moved(Direction::Left), Cursor::Dozen(0));
+    assert_eq!(Cursor::Outside(5).moved(Direction::Right), Cursor::Outside(5));
 }
 
 #[test]
@@ -305,6 +351,7 @@ fn every_cursor_round_trips_through_its_encoded_form() {
     }
     assert_eq!(Cursor::parse("nonsense"), Cursor::default());
     assert_eq!(Cursor::parse("lattice:99:0"), Cursor::default());
+    assert_eq!(Cursor::parse("lattice:0:1"), Cursor::default());
     assert_eq!(Cursor::parse("dozen:7"), Cursor::default());
 }