v2.1.0: add European roulette with split bets and wheel animation

3 files changed, 331 insertions, 0 deletions

diff --git a/tests/client_core.rs b/tests/client_core.rs
index 4749d99..7fb7e29 100644
--- a/tests/client_core.rs
+++ b/tests/client_core.rs
@@ -47,6 +47,15 @@ impl Screen {
                     self.region_start = None;
                     self.region_len = 0;
                 }
+                Effect::AnimateRoulette { final_lines, .. } => {
+                    if let Some(start) = self.region_start {
+                        self.lines.truncate(start);
+                    } else {
+                        self.region_start = Some(self.lines.len());
+                    }
+                    self.lines.extend(final_lines.iter().cloned());
+                    self.region_len = final_lines.len();
+                }
                 Effect::SetPrompt { text, cursor_col } => {
                     self.prompt = text.clone();
                     self.prompt_cursor = *cursor_col;
@@ -125,6 +134,11 @@ impl Harness {
         self.line(&format!("play slots {bet}"));
         self.reply("INFO alice 1 1000");
     }
+
+    fn enter_roulette(&mut self) {
+        self.line("play roulette");
+        self.reply("INFO alice 1 1000");
+    }
 }
 
 #[test]
@@ -559,3 +573,77 @@ fn rejects_a_grid_with_the_wrong_size() {
 
     assert!(parse_spin_response(response).is_err());
 }
+
+#[test]
+fn roulette_split_bets_spin_and_show_the_result() {
+    let mut h = Harness::new();
+    h.enter_roulette();
+
+    assert_eq!(h.board().len(), 8);
+    assert_eq!(h.board()[0], "=== ROULETTE ===");
+    assert!(h.board()[1].contains("Balance: 1000 PLN"));
+    assert!(h.board()[1].contains("Chip: 10 PLN"));
+    assert!(h.board()[2].contains("Bets: (none)"));
+
+    h.key(Key::Char('r'));
+    h.key(Key::Char('e'));
+    h.key(Key::Char('1'));
+    h.key(Key::Char('7'));
+    h.key(Key::Enter);
+
+    assert!(h.board()[2].contains("RED 10"));
+    assert!(h.board()[2].contains("EVEN 10"));
+    assert!(h.board()[2].contains("#17 10"));
+    assert!(h.board()[2].contains("Total: 30 PLN"));
+
+    h.key(Key::Char(' '));
+    let request = h
+        .sent
+        .iter()
+        .find(|line| line.starts_with("PLAY_START roulette"))
+        .expect("roulette request");
+    assert_eq!(
+        request,
+        "PLAY_START roulette 30 {\"red\":10,\"black\":0,\"even\":10,\"odd\":0,\"numbers\":[{\"number\":17,\"amount\":10}]}"
+    );
+
+    let bets =
+        r#"{"red":10,"black":0,"even":10,"odd":0,"numbers":[{"number":17,"amount":10}]}"#;
+    h.reply(&format!(
+        "ROULETTE_RESULT session-1 360 30 1330 17 black {bets}"
+    ));
+
+    assert_eq!(h.board().len(), 8);
+    assert!(h.board()[1].contains("Balance: 1330 PLN"));
+    assert!(h.board()[4].contains("Winning: 17 BLACK ODD"));
+    assert!(h.board()[5].contains("Won 360 PLN"));
+}
+
+#[test]
+fn roulette_rejects_an_empty_spin_and_accepts_the_equals_chip_key() {
+    let mut h = Harness::new();
+    h.enter_roulette();
+
+    h.key(Key::Char(' '));
+    assert!(h.board()[4].contains("ERROR: Place at least one bet"));
+    assert!(!h.sent.iter().any(|line| line.starts_with("PLAY_START roulette")));
+
+    h.key(Key::Char('='));
+    assert!(h.board()[1].contains("Chip: 20 PLN"));
+    h.key(Key::Char('r'));
+    assert!(h.board()[2].contains("RED 20"));
+    assert!(h.board()[2].contains("Total: 20 PLN"));
+}
+
+#[test]
+fn roulette_rejects_an_out_of_range_number() {
+    let mut h = Harness::new();
+    h.enter_roulette();
+
+    h.key(Key::Char('9'));
+    h.key(Key::Char('9'));
+    h.key(Key::Enter);
+
+    assert!(h.board()[4].contains("ERROR: Number must be 0-36"));
+    assert!(h.board()[2].contains("Bets: (none)"));
+}
diff --git a/tests/roulette.rs b/tests/roulette.rs
new file mode 100644
index 0000000..6b99d17
--- /dev/null
+++ b/tests/roulette.rs
@@ -0,0 +1,184 @@
+use zagan_bet::roulette::{
+    color, is_black, is_even, is_odd, is_red, rtp, Bets, NumberBet, WHEEL,
+};
+use zagan_bet::server::games::roulette::RouletteGame;
+use zagan_bet::server::games::traits::Game;
+
+#[test]
+fn the_european_wheel_has_all_37_unique_pockets() {
+    let mut numbers = WHEEL.to_vec();
+    numbers.sort_unstable();
+    assert_eq!(numbers, (0..=36).collect::<Vec<_>>());
+    assert_eq!(color(0), "green");
+    assert_eq!(WHEEL.len(), 37);
+}
+
+#[test]
+fn colors_and_even_odd_are_correct() {
+    assert!(is_red(1));
+    assert!(is_black(2));
+    assert!(!is_red(0));
+    assert!(!is_black(0));
+    assert!(is_even(2));
+    assert!(is_odd(3));
+    assert!(!is_even(0));
+    assert!(!is_odd(0));
+    assert_eq!(color(17), "black");
+    assert_eq!(color(18), "red");
+}
+
+#[test]
+fn european_rtp_is_36_over_37() {
+    assert!((rtp() - 36.0 / 37.0).abs() < 1e-12);
+}
+
+#[test]
+fn bets_total_and_winning_number_payouts() {
+    let bets = Bets {
+        red: 10,
+        black: 10,
+        even: 10,
+        odd: 10,
+        numbers: vec![NumberBet {
+            number: 17,
+            amount: 5,
+        }],
+    };
+
+    assert_eq!(bets.total(), 45);
+    // 17 is black and odd: 10*2 + 10*2 + 5*36.
+    assert_eq!(bets.winnings(17), 220);
+    // 18 is red and even.
+    assert_eq!(bets.winnings(18), 40);
+}
+
+#[test]
+fn zero_loses_all_outside_bets_but_pays_a_straight_zero() {
+    let outside = Bets {
+        red: 10,
+        black: 10,
+        even: 10,
+        odd: 10,
+        numbers: vec![],
+    };
+    assert_eq!(outside.winnings(0), 0);
+
+    let straight = Bets {
+        red: 10,
+        black: 10,
+        even: 10,
+        odd: 10,
+        numbers: vec![NumberBet {
+            number: 0,
+            amount: 5,
+        }],
+    };
+    assert_eq!(straight.total(), 45);
+    assert_eq!(straight.winnings(0), 180);
+}
+
+#[test]
+fn bets_validate_empty_balance_and_invalid_numbers() {
+    assert!(Bets::default().validate(1000).is_err());
+
+    let too_big = Bets {
+        red: 2000,
+        ..Bets::default()
+    };
+    assert!(too_big.validate(1000).is_err());
+
+    let bad_number = Bets {
+        numbers: vec![NumberBet {
+            number: 37,
+            amount: 10,
+        }],
+        ..Bets::default()
+    };
+    assert!(bad_number.validate(1000).is_err());
+}
+
+#[test]
+fn the_server_settles_a_split_bet() {
+    let bets = Bets {
+        red: 10,
+        black: 10,
+        even: 10,
+        odd: 10,
+        numbers: vec![NumberBet {
+            number: 17,
+            amount: 5,
+        }],
+    };
+    let payload = serde_json::to_string(&bets).unwrap();
+    let game = RouletteGame::with_result(17);
+    let state = game.prepare_state("alice", bets.total());
+
+    let state = game.process_action(&state, "spin", &[&payload]).unwrap();
+    let result = game.calculate_result(&state).unwrap();
+
+    assert_eq!(result.winnings, 220);
+    assert_eq!(result.result_data.get("number").unwrap(), "17");
+    assert_eq!(result.result_data.get("color").unwrap(), "black");
+    assert_eq!(result.result_data.get("bets").unwrap(), &payload);
+}
+
+#[test]
+fn the_server_rejects_a_total_that_does_not_match_the_bets() {
+    let payload = serde_json::to_string(&Bets {
+        red: 10,
+        ..Bets::default()
+    })
+    .unwrap();
+    let game = RouletteGame::with_result(17);
+    let state = game.prepare_state("alice", 99);
+
+    assert!(game.process_action(&state, "spin", &[&payload]).is_err());
+}
+
+#[test]
+fn the_server_rejects_an_invalid_number() {
+    let payload = serde_json::to_string(&Bets {
+        numbers: vec![NumberBet {
+            number: 37,
+            amount: 10,
+        }],
+        ..Bets::default()
+    })
+    .unwrap();
+    let game = RouletteGame::with_result(17);
+    let state = game.prepare_state("alice", 10);
+
+    assert!(game.process_action(&state, "spin", &[&payload]).is_err());
+}
+
+#[test]
+fn parses_a_roulette_result() {
+    let bets = r#"{"red":10,"black":0,"even":10,"odd":0,"numbers":[{"number":17,"amount":10}]}"#;
+    let response = format!("ROULETTE_RESULT session-1 360 30 1330 17 black {bets}");
+    let result = zagan_bet::client::games::response::parse_roulette_response(&response).unwrap();
+
+    assert_eq!(result.session_id, "session-1");
+    assert_eq!(result.winnings, 360);
+    assert_eq!(result.bet_amount, 30);
+    assert_eq!(result.balance, 1330);
+    assert_eq!(result.number, 17);
+    assert_eq!(result.color, "black");
+    assert_eq!(result.bets, bets);
+}
+
+#[test]
+fn rejects_bad_roulette_results() {
+    use zagan_bet::client::games::response::parse_roulette_response;
+
+    let valid_bets = r#"{"red":10}"#;
+    assert!(parse_roulette_response(&format!(
+        "ROULETTE_RESULT s 1 1 1 37 green {valid_bets}"
+    ))
+    .is_err());
+    assert!(parse_roulette_response(&format!(
+        "ROULETTE_RESULT s 1 1 1 17 purple {valid_bets}"
+    ))
+    .is_err());
+    assert!(parse_roulette_response("ROULETTE_RESULT s 1 1 1 17 black nope").is_err());
+    assert!(parse_roulette_response("").is_err());
+}
diff --git a/tests/server_core.rs b/tests/server_core.rs
index cab74a7..cf05102 100644
--- a/tests/server_core.rs
+++ b/tests/server_core.rs
@@ -4,7 +4,9 @@ use rusqlite::Connection;
 use zagan_bet::server::core::{ConnectionState, ServerCore};
 use zagan_bet::server::database;
 use zagan_bet::server::games::registry::GameRegistry;
+use zagan_bet::server::games::roulette::RouletteGame;
 use zagan_bet::server::games::slots::SlotsGame;
+use zagan_bet::roulette::Bets;
 
 fn setup(name: &str, grid: &str) -> (ServerCore, String) {
     let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
@@ -29,6 +31,22 @@ const LOSS: &str = "CLOOGDSLCDCOGLS";
 /// Top line is C C C D D; it pays 2x total bet.
 const WIN3: &str = "CCCCLLCLODGSDGS";
 
+fn setup_roulette(name: &str, number: u8) -> (ServerCore, String) {
+    let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
+        .join(format!("server-core-{name}.db"))
+        .to_string_lossy()
+        .into_owned();
+    let _ = std::fs::remove_file(&path);
+
+    let conn = Connection::open(&path).unwrap();
+    database::init_db(&conn);
+
+    let registry = GameRegistry::new();
+    registry.register_game(RouletteGame::with_result(number));
+
+    (ServerCore::with_registry(conn, registry, 4), path)
+}
+
 fn register(core: &mut ServerCore, state: &mut ConnectionState, user: &str) {
     assert_eq!(
         core.handle_message(state, &format!("REGISTER {user} credential")),
@@ -164,6 +182,47 @@ fn plays_record_the_game_type_and_game_specific_details() {
 }
 
 #[test]
+fn roulette_settles_split_bets_and_records_details() {
+    let (mut core, path) = setup_roulette("roulette", 17);
+    let mut state = ConnectionState::default();
+    register(&mut core, &mut state, "alice");
+    login(&mut core, &mut state, "alice");
+
+    let bets =
+        r#"{"red":10,"black":10,"even":10,"odd":10,"numbers":[{"number":17,"amount":5}]}"#;
+    let response = core.handle_message(&mut state, &format!("PLAY_START roulette 45 {bets}"));
+
+    assert!(
+        response.starts_with("ROULETTE_RESULT"),
+        "response: {response}"
+    );
+    assert!(
+        response.contains(" 220 45 1175 17 black "),
+        "response: {response}"
+    );
+    assert!(response.ends_with(&format!(" {bets}")), "response: {response}");
+    assert_eq!(core.balance("alice"), Some(1175));
+    assert_eq!(core.play_count("alice"), 1);
+    assert_eq!(core.session_count(), 0);
+
+    let conn = Connection::open(&path).unwrap();
+    let (game_type, details): (String, String) = conn
+        .query_row(
+            "SELECT game_type, details FROM plays WHERE username = 'alice'",
+            [],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )
+        .unwrap();
+
+    assert_eq!(game_type, "roulette");
+    let details: serde_json::Value = serde_json::from_str(&details).unwrap();
+    assert_eq!(details["number"], "17");
+    assert_eq!(details["color"], "black");
+    let stored: Bets = serde_json::from_str(details["bets"].as_str().unwrap()).unwrap();
+    assert_eq!(stored.total(), 45);
+}
+
+#[test]
 fn a_failed_audit_insert_rolls_back_the_balance_change() {
     let (mut core, path) = setup("rollback", LOSS);
     let mut state = ConnectionState::default();