3 files changed, 197 insertions, 101 deletions

diff --git a/tests/client_core.rs b/tests/client_core.rs
index c298ab7..80ec587 100644
--- a/tests/client_core.rs
+++ b/tests/client_core.rs
@@ -5,8 +5,13 @@
 //! player would see, not about ANSI sequences.
 
 use zagan_bet::client::core::{ClientCore, Effect, InteractiveCommand, Key};
+use zagan_bet::client::games::response::parse_spin_response;
 use zagan_bet::client::ui::command_names;
 
+const WIN3: &str = "CCCCLLCLODGSDGS";
+const LOSS: &str = "CLOOGDSLCDCOGLS";
+const ALL_C: &str = "CCCCCCCCCCCCCCC";
+
 #[derive(Default)]
 struct Screen {
     lines: Vec<String>,
@@ -123,16 +128,17 @@ impl Harness {
 }
 
 #[test]
-fn play_shows_a_seven_line_board_and_fetches_the_balance() {
+fn play_shows_a_nine_line_board_and_fetches_the_balance() {
     let mut h = Harness::new();
     h.line("play slots 50");
 
-    assert_eq!(h.board().len(), 7);
+    assert_eq!(h.board().len(), 9);
     assert!(h.board()[1].contains("Bet: 50 PLN"));
+    assert!(h.board()[1].contains("Lines: 5"));
     assert!(h.sent.contains(&"INFO".to_string()));
 
     h.reply("INFO alice 1 1000");
-    assert_eq!(h.board().len(), 7);
+    assert_eq!(h.board().len(), 9);
     assert!(h.board()[1].contains("Balance: 1000 PLN"));
 }
 
@@ -143,18 +149,22 @@ fn spin_replaces_the_board_and_keeps_the_controls_line() {
     let lines_before_spin = h.screen.lines.len();
 
     h.key(Key::Char(' '));
-    assert_eq!(h.board().len(), 7);
-    assert!(h.board()[4].contains("Spinning..."));
-    assert!(h.board()[6].contains("[Q] Quit"));
+    assert_eq!(h.board().len(), 9);
+    assert!(h.board()[6].contains("Spinning..."));
+    assert!(h.board()[8].contains("[Q] Quit"));
     assert!(h.sent.iter().any(|line| line == "PLAY_START slots 50"));
     assert_eq!(h.screen.lines.len(), lines_before_spin);
 
-    h.reply("GAME_RESULT session-1 60 50 1010 OSS two");
-    assert_eq!(h.board().len(), 7);
-    assert!(h.board()[2].contains("[ O ] [ S ] [ S ]"));
-    assert!(h.board()[4].contains("Two of a kind! Winnings: 60 PLN"));
-    assert!(h.board()[1].contains("Balance: 1010 PLN"));
-    assert!(h.board()[6].contains("[Q] Quit"));
+    h.reply("GAME_RESULT session-1 100 50 1050 CCCCLLCLODGSDGS win 1");
+    assert_eq!(h.board().len(), 9);
+    assert!(h
+        .board()
+        .get(2)
+        .is_some_and(|line| line.contains("[ C ] [ C ] [ C ] [ D ] [ D ]")));
+    assert!(h.board()[6].contains("Won 100 PLN"));
+    assert!(h.board()[7].contains("Winning lines: 1"));
+    assert!(h.board()[1].contains("Balance: 1050 PLN"));
+    assert!(h.board()[8].contains("[Q] Quit"));
     assert_eq!(h.screen.lines.len(), lines_before_spin);
 }
 
@@ -163,14 +173,17 @@ fn changing_the_bet_after_a_spin_does_not_leave_stale_lines() {
     let mut h = Harness::new();
     h.enter_slots("50");
     h.key(Key::Char(' '));
-    h.reply("GAME_RESULT session-1 60 50 1010 OSS two");
+    h.reply("GAME_RESULT session-1 100 50 1050 CCCCLLCLODGSDGS win 1");
     let lines_before_bet = h.screen.lines.len();
 
     h.key(Key::Char('+'));
 
-    assert_eq!(h.board().len(), 7);
+    assert_eq!(h.board().len(), 9);
     assert!(h.board()[1].contains("Bet: 60 PLN"));
-    assert!(h.board()[2].contains("[ O ] [ S ] [ S ]"));
+    assert!(h
+        .board()
+        .get(2)
+        .is_some_and(|line| line.contains("[ C ] [ C ] [ C ] [ D ] [ D ]")));
     assert_eq!(h.screen.lines.len(), lines_before_bet);
     assert_eq!(
         h.screen
@@ -183,6 +196,32 @@ fn changing_the_bet_after_a_spin_does_not_leave_stale_lines() {
 }
 
 #[test]
+fn a_losing_spin_shows_no_win_and_no_winning_lines() {
+    let mut h = Harness::new();
+    h.enter_slots("10");
+    h.key(Key::Char(' '));
+
+    h.reply(&format!("GAME_RESULT session-1 0 10 990 {LOSS} none -"));
+
+    assert_eq!(h.board().len(), 9);
+    assert!(h.board()[6].contains("No win."));
+    assert_eq!(h.board()[7], "");
+}
+
+#[test]
+fn a_mega_win_shows_all_winning_lines() {
+    let mut h = Harness::new();
+    h.enter_slots("10");
+    h.key(Key::Char(' '));
+
+    h.reply(&format!("GAME_RESULT session-1 750 10 1740 {ALL_C} mega 1,2,3,4,5"));
+
+    assert_eq!(h.board().len(), 9);
+    assert!(h.board()[6].contains("MEGA WIN! 750 PLN"));
+    assert!(h.board()[7].contains("Winning lines: 1,2,3,4,5"));
+}
+
+#[test]
 fn quitting_clears_the_board_and_returns_the_prompt() {
     let mut h = Harness::new();
     h.enter_slots("50");
@@ -202,8 +241,8 @@ fn a_server_error_replaces_the_status_line() {
 
     h.reply("ERROR Insufficient balance");
 
-    assert_eq!(h.board().len(), 7);
-    assert!(h.board()[4].contains("ERROR: Insufficient balance"));
+    assert_eq!(h.board().len(), 9);
+    assert!(h.board()[6].contains("ERROR: Insufficient balance"));
     assert!(h.board()[2].contains("[ ? ]"));
     assert!(!h.board().iter().any(|line| line.contains("Spinning")));
 }
@@ -216,8 +255,8 @@ fn an_empty_reply_is_an_error_not_a_silent_spin() {
 
     h.reply("");
 
-    assert_eq!(h.board().len(), 7);
-    assert!(h.board()[4].contains("No response from server"));
+    assert_eq!(h.board().len(), 9);
+    assert!(h.board()[6].contains("No response from server"));
 }
 
 #[test]
@@ -301,7 +340,7 @@ fn play_without_a_bet_uses_the_default() {
     let mut h = Harness::new();
     h.line("play slots");
 
-    assert_eq!(h.board().len(), 7);
+    assert_eq!(h.board().len(), 9);
     assert!(h.board()[1].contains("Bet: 10 PLN"));
 }
 
@@ -475,3 +514,30 @@ fn disconnect_clears_connection_state() {
         .iter()
         .any(|line| line.contains("Not connected")));
 }
+
+#[test]
+fn parses_a_five_by_three_result_with_winning_lines() {
+    let response = format!("GAME_RESULT session-1 100 50 1050 {WIN3} win 1");
+    let result = parse_spin_response(&response).expect("valid 5x3 result");
+
+    assert_eq!(result.reels.chars().count(), 15);
+    assert_eq!(result.win_type, "win");
+    assert_eq!(result.win_lines, vec![1]);
+}
+
+#[test]
+fn accepts_a_legacy_three_symbol_result() {
+    let result = parse_spin_response("GAME_RESULT session-1 60 10 1050 OSS two")
+        .expect("legacy result should still parse");
+
+    assert_eq!(result.reels, "OSS");
+    assert_eq!(result.win_type, "two");
+    assert!(result.win_lines.is_empty());
+}
+
+#[test]
+fn rejects_a_grid_with_the_wrong_size() {
+    let response = "GAME_RESULT session-1 100 50 1050 CCCCCCCCCCCCCC win 1";
+
+    assert!(parse_spin_response(response).is_err());
+}
diff --git a/tests/server_core.rs b/tests/server_core.rs
index fe2b3d3..f3736e9 100644
--- a/tests/server_core.rs
+++ b/tests/server_core.rs
@@ -6,7 +6,7 @@ use zagan_bet::server::database;
 use zagan_bet::server::games::registry::GameRegistry;
 use zagan_bet::server::games::slots::SlotsGame;
 
-fn setup(name: &str, reels: &str) -> (ServerCore, String) {
+fn setup(name: &str, grid: &str) -> (ServerCore, String) {
     let path = PathBuf::from(env!("CARGO_TARGET_TMPDIR"))
         .join(format!("server-core-{name}.db"))
         .to_string_lossy()
@@ -17,12 +17,18 @@ fn setup(name: &str, reels: &str) -> (ServerCore, String) {
     database::init_db(&conn);
 
     let registry = GameRegistry::new();
-    registry.register_game(SlotsGame::with_reels(reels));
+    registry.register_game(SlotsGame::with_grid(grid));
 
     // Low bcrypt cost keeps the tests fast.
     (ServerCore::with_registry(conn, registry, 4), path)
 }
 
+/// Column-major 5x3 grid with no winning line.
+const LOSS: &str = "CLOOGDSLCDCOGLS";
+
+/// Top line is C C C D D; it pays 2x total bet.
+const WIN3: &str = "CCCCLLCLODGSDGS";
+
 fn register(core: &mut ServerCore, state: &mut ConnectionState, user: &str) {
     assert_eq!(
         core.handle_message(state, &format!("REGISTER {user} credential")),
@@ -39,7 +45,7 @@ fn login(core: &mut ServerCore, state: &mut ConnectionState, user: &str) {
 
 #[test]
 fn register_stores_a_bcrypt_hash_and_auth_accepts_it() {
-    let (mut core, path) = setup("register", "CLO");
+    let (mut core, path) = setup("register", LOSS);
     let mut state = ConnectionState::default();
 
     register(&mut core, &mut state, "alice");
@@ -59,7 +65,7 @@ fn register_stores_a_bcrypt_hash_and_auth_accepts_it() {
 
 #[test]
 fn the_same_credential_gets_a_different_salt() {
-    let (mut core, path) = setup("salt", "CLO");
+    let (mut core, path) = setup("salt", LOSS);
     let mut state = ConnectionState::default();
 
     register(&mut core, &mut state, "alice");
@@ -73,7 +79,7 @@ fn the_same_credential_gets_a_different_salt() {
 
 #[test]
 fn legacy_sha256_rows_are_upgraded_on_login() {
-    let (mut core, path) = setup("legacy", "CLO");
+    let (mut core, path) = setup("legacy", LOSS);
     let conn = Connection::open(&path).unwrap();
     database::add_user(&conn, "legacy", "deadbeef").unwrap();
 
@@ -96,7 +102,7 @@ fn legacy_sha256_rows_are_upgraded_on_login() {
 
 #[test]
 fn duplicate_registration_returns_an_error() {
-    let (mut core, _path) = setup("duplicate", "CLO");
+    let (mut core, _path) = setup("duplicate", LOSS);
     let mut state = ConnectionState::default();
 
     register(&mut core, &mut state, "alice");
@@ -108,7 +114,7 @@ fn duplicate_registration_returns_an_error() {
 
 #[test]
 fn a_malicious_username_cannot_change_another_balance() {
-    let (mut core, _path) = setup("injection", "CLO");
+    let (mut core, _path) = setup("injection", LOSS);
     let mut admin = ConnectionState::default();
     register(&mut core, &mut admin, "victim");
 
@@ -132,7 +138,7 @@ fn a_malicious_username_cannot_change_another_balance() {
 
 #[test]
 fn a_failed_audit_insert_rolls_back_the_balance_change() {
-    let (mut core, path) = setup("rollback", "CLO");
+    let (mut core, path) = setup("rollback", LOSS);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -155,7 +161,7 @@ fn a_failed_audit_insert_rolls_back_the_balance_change() {
 
 #[test]
 fn spins_write_audit_rows_and_leave_no_sessions() {
-    let (mut core, _path) = setup("audit", "CLO");
+    let (mut core, _path) = setup("audit", LOSS);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -175,7 +181,7 @@ fn spins_write_audit_rows_and_leave_no_sessions() {
 
 #[test]
 fn a_winning_spin_updates_the_balance_and_the_audit_row() {
-    let (mut core, _path) = setup("win", "CCC");
+    let (mut core, _path) = setup("win", WIN3);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -183,6 +189,7 @@ fn a_winning_spin_updates_the_balance_and_the_audit_row() {
     let response = core.handle_message(&mut state, "PLAY_START slots 10");
     assert!(response.starts_with("GAME_RESULT"), "spin failed: {response}");
     assert!(response.contains(" 20 10 1010 "), "response: {response}");
+    assert!(response.ends_with(" win 1"), "response: {response}");
 
     assert_eq!(core.balance("alice"), Some(1010));
     assert_eq!(core.play_count("alice"), 1);
@@ -191,7 +198,7 @@ fn a_winning_spin_updates_the_balance_and_the_audit_row() {
 
 #[test]
 fn insufficient_balance_does_not_write_an_audit_row() {
-    let (mut core, path) = setup("insufficient", "CLO");
+    let (mut core, path) = setup("insufficient", LOSS);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -211,7 +218,7 @@ fn insufficient_balance_does_not_write_an_audit_row() {
 
 #[test]
 fn a_negative_balance_is_rejected_without_wrapping() {
-    let (mut core, path) = setup("negative", "CLO");
+    let (mut core, path) = setup("negative", LOSS);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
@@ -233,7 +240,7 @@ fn a_negative_balance_is_rejected_without_wrapping() {
 
 #[test]
 fn unknown_games_are_rejected_before_a_session_is_created() {
-    let (mut core, _path) = setup("unknown", "CLO");
+    let (mut core, _path) = setup("unknown", LOSS);
     let mut state = ConnectionState::default();
     register(&mut core, &mut state, "alice");
     login(&mut core, &mut state, "alice");
diff --git a/tests/slots.rs b/tests/slots.rs
index 3035800..5fb751a 100644
--- a/tests/slots.rs
+++ b/tests/slots.rs
@@ -1,99 +1,122 @@
-//! Regression tests for the server-side slots game logic.
+//! Regression tests for the server-side 5x3 slots game.
 
-use zagan_bet::server::games::slots::SlotsGame;
+use zagan_bet::server::games::slots::{SlotsGame, PAYLINES, REELS, ROWS};
 use zagan_bet::server::games::traits::{Game, GamePhase};
 
-fn make_game() -> SlotsGame {
-    SlotsGame::new()
+/// Convert row-major test rows into the column-major wire format.
+fn grid(rows: [&str; 3]) -> String {
+    let cells: Vec<Vec<char>> = rows.iter().map(|row| row.chars().collect()).collect();
+    let mut result = String::new();
+    for col in 0..REELS {
+        for row in 0..ROWS {
+            result.push(cells[row][col]);
+        }
+    }
+    result
+}
+
+fn payout(rows: [&str; 3], bet: u64) -> (u64, Vec<usize>) {
+    let reels = grid(rows);
+    let game = SlotsGame::with_grid(&reels);
+    let cells: Vec<char> = reels.chars().collect();
+    game.calculate_payout(&cells, bet)
+}
+
+#[test]
+fn the_wire_grid_is_five_reels_by_three_rows() {
+    assert_eq!(REELS, 5);
+    assert_eq!(ROWS, 3);
+    assert_eq!(PAYLINES.len(), 5);
+
+    let game = SlotsGame::new();
+    let state = game.prepare_state("alice", 10);
+    let state = game.process_action(&state, "spin", &[]).unwrap();
+    let reels = state.data.get("reels").unwrap();
+    assert_eq!(reels.chars().count(), REELS * ROWS);
 }
 
-/// Three of a kind pays the three-of-a-kind multiplier.
 #[test]
-fn three_of_a_kind_pays() {
-    let game = make_game();
-    // CCC = 2x
-    assert_eq!(game.calculate_payout(&['C', 'C', 'C'], 100), 200);
-    // SSS = 28x
-    assert_eq!(game.calculate_payout(&['S', 'S', 'S'], 10), 280);
+fn three_of_a_kind_on_the_top_line_pays() {
+    let (winnings, lines) = payout(["CCCDD", "CLLGG", "CLOSS"], 10);
+
+    assert_eq!(winnings, 20, "CCC on line 1 pays 2x total bet");
+    assert_eq!(lines, vec![1]);
 }
 
-/// Two adjacent matching symbols pays the two-of-a-kind multiplier.
 #[test]
-fn two_adjacent_pays() {
-    let game = make_game();
-    // CC? = 1x
-    assert_eq!(game.calculate_payout(&['C', 'C', 'D'], 100), 100);
-    // ?LL = 1x
-    assert_eq!(game.calculate_payout(&['D', 'L', 'L'], 50), 50);
+fn four_of_a_kind_pays_more_than_three() {
+    let (winnings, lines) = payout(["CCCCD", "LOGDS", "OGDSL"], 10);
+
+    assert_eq!(winnings, 50, "CCCC pays 5x total bet");
+    assert_eq!(lines, vec![1]);
 }
 
-/// Non-adjacent matching symbols (e.g. [C,D,C]) must also pay.
-/// This was a bug: the old code only checked pairs (0,1) and (1,2).
 #[test]
-fn two_non_adjacent_pays() {
-    let game = make_game();
-    // C,D,C — two cherries at positions 0 and 2
-    assert_eq!(game.calculate_payout(&['C', 'D', 'C'], 100), 100);
-    // S,X,S — two sevens at positions 0 and 2
-    assert_eq!(game.calculate_payout(&['S', 'L', 'S'], 10), 30);
-    // L,O,L
-    assert_eq!(game.calculate_payout(&['L', 'O', 'L'], 50), 50);
+fn five_of_a_kind_pays_all_lines() {
+    let (winnings, lines) = payout(["SSSSS", "SSSSS", "SSSSS"], 10);
+
+    assert_eq!(winnings, 7500, "five SSSSS lines at 150x each");
+    assert_eq!(lines, vec![1, 2, 3, 4, 5]);
 }
 
-/// No matching symbols returns 0.
 #[test]
-fn no_match_returns_zero() {
-    let game = make_game();
-    assert_eq!(game.calculate_payout(&['C', 'L', 'O'], 100), 0);
-    assert_eq!(game.calculate_payout(&['G', 'D', 'S'], 50), 0);
+fn the_v_payline_is_evaluated() {
+    let (winnings, lines) = payout(["COGDC", "LCLCG", "OGCSD"], 10);
+
+    assert_eq!(winnings, 150, "V line with five C symbols pays 15x");
+    assert_eq!(lines, vec![4]);
 }
 
 #[test]
-fn an_enormous_bet_saturates_instead_of_overflowing() {
-    let game = make_game();
-    assert_eq!(game.calculate_payout(&['S', 'S', 'S'], u64::MAX), u64::MAX);
-    assert_eq!(game.calculate_payout(&['S', 'L', 'S'], u64::MAX), u64::MAX);
+fn no_matching_line_pays_nothing() {
+    let (winnings, lines) = payout(["CLOGD", "LOSGC", "DGDSC"], 100);
+
+    assert_eq!(winnings, 0);
+    assert!(lines.is_empty());
 }
 
-/// process_action produces a finished state with correct reels and win_type.
 #[test]
-fn process_action_spin_sets_finished() {
-    let game = make_game();
-    let state = game.prepare_state("alice", 100);
-    assert_eq!(state.phase, GamePhase::WaitingToStart);
-
-    // Manually set reels by going through process_action.
-    // Since spin is random, we test the state machine rather than the outcome.
-    let result = game.process_action(&state, "spin", &[]);
-    assert!(result.is_ok());
-    let new_state = result.unwrap();
-    assert_eq!(new_state.phase, GamePhase::Finished);
-    assert!(new_state.data.contains_key("reels"));
-    assert!(new_state.data.contains_key("win_type"));
+fn winning_lines_are_added_together() {
+    let (winnings, lines) = payout(["SSSSS", "LLLLL", "OOOOO"], 10);
+
+    assert_eq!(winnings, (150 + 20 + 25) * 10);
+    assert_eq!(lines, vec![1, 2, 3]);
+}
+
+#[test]
+fn theoretical_rtp_is_just_under_one() {
+    let rtp = SlotsGame::new().theoretical_rtp();
+
+    assert!((rtp - 425.0 / 432.0).abs() < 1e-12);
+    assert!(rtp < 1.0, "house edge must be positive");
+    assert!(rtp > 0.98, "house edge should be tiny");
+}
+
+#[test]
+fn an_enormous_bet_saturates_instead_of_overflowing() {
+    let (winnings, _) = payout(["SSSSS", "SSSSS", "SSSSS"], u64::MAX);
+
+    assert_eq!(winnings, u64::MAX);
 }
 
-/// calculate_result on a finished state returns valid GameResult.
 #[test]
-fn calculate_result_on_finished_state() {
-    let game = make_game();
-    let mut state = game.prepare_state("alice", 100);
-    state.phase = GamePhase::Finished;
-    state
-        .data
-        .insert("reels".to_string(), "CCD".to_string());
-    state
-        .data
-        .insert("win_type".to_string(), "two".to_string());
+fn a_spin_produces_a_finished_state_and_a_result_with_win_lines() {
+    let game = SlotsGame::with_grid(&grid(["CCCDD", "CLLGG", "CLOSS"]));
+    let state = game.prepare_state("alice", 10);
+
+    let state = game.process_action(&state, "spin", &[]).unwrap();
+    assert_eq!(state.phase, GamePhase::Finished);
 
     let result = game.calculate_result(&state).unwrap();
-    assert_eq!(result.bet_amount, 100);
-    assert_eq!(result.winnings, 100); // CC = 1x
+    assert_eq!(result.winnings, 20);
+    assert_eq!(result.result_data.get("win_type").unwrap(), "win");
+    assert_eq!(result.result_data.get("win_lines").unwrap(), "1");
 }
 
-/// calculate_result on a non-finished state returns an error.
 #[test]
-fn calculate_result_on_unfinished_state() {
-    let game = make_game();
-    let state = game.prepare_state("alice", 100);
+fn calculate_result_rejects_an_unfinished_state() {
+    let game = SlotsGame::new();
+    let state = game.prepare_state("alice", 10);
+
     assert!(game.calculate_result(&state).is_err());
 }