v1.0.0: replace slots with 5x3 reels and five paylines

5 files changed, 233 insertions, 107 deletions

diff --git a/src/client/games/manager.rs b/src/client/games/manager.rs
index 71cd28c..8436142 100644
--- a/src/client/games/manager.rs
+++ b/src/client/games/manager.rs
@@ -75,6 +75,7 @@ impl GameManager {
         session.data.remove("error");
         session.data.remove("reels");
         session.data.remove("win_type");
+        session.data.remove("win_lines");
         session.data.remove("winnings");
         Ok(())
     }
@@ -91,6 +92,15 @@ impl GameManager {
         session
             .data
             .insert("win_type".to_string(), result.win_type);
+        session.data.insert(
+            "win_lines".to_string(),
+            result
+                .win_lines
+                .iter()
+                .map(usize::to_string)
+                .collect::<Vec<_>>()
+                .join(","),
+        );
         session
             .data
             .insert("winnings".to_string(), result.winnings.to_string());
@@ -107,6 +117,7 @@ impl GameManager {
         session.phase = GamePhase::WaitingToStart;
         session.data.remove("reels");
         session.data.remove("win_type");
+        session.data.remove("win_lines");
         session.data.remove("winnings");
         session.data.insert("error".to_string(), message.into());
     }
diff --git a/src/client/games/response.rs b/src/client/games/response.rs
index 6948805..de22a75 100644
--- a/src/client/games/response.rs
+++ b/src/client/games/response.rs
@@ -6,6 +6,7 @@ pub struct SpinResult {
     pub balance: i64,
     pub reels: String,
     pub win_type: String,
+    pub win_lines: Vec<usize>,
 }
 
 /// Parse one server reply to `PLAY_START`.
@@ -45,10 +46,19 @@ pub fn parse_spin_response(response: &str) -> Result<SpinResult, String> {
         .parse::<i64>()
         .map_err(|_| format!("Invalid balance from server: {}", parts[4]))?;
 
-    if parts[5].chars().count() != 3 {
+    if parts[5].chars().count() != 3 && parts[5].chars().count() != 15 {
         return Err(format!("Invalid reels from server: {}", parts[5]));
     }
 
+    let win_lines = parts
+        .get(7)
+        .map(|raw| {
+            raw.split(',')
+                .filter_map(|value| value.trim().parse::<usize>().ok())
+                .collect()
+        })
+        .unwrap_or_default();
+
     Ok(SpinResult {
         session_id: parts[1].to_string(),
         winnings,
@@ -56,5 +66,6 @@ pub fn parse_spin_response(response: &str) -> Result<SpinResult, String> {
         balance,
         reels: parts[5].to_string(),
         win_type: parts[6].to_string(),
+        win_lines,
     })
 }
diff --git a/src/client/games/slots.rs b/src/client/games/slots.rs
index 5eed34d..39c43b2 100644
--- a/src/client/games/slots.rs
+++ b/src/client/games/slots.rs
@@ -1,8 +1,10 @@
 use super::traits::{Game, GamePhase, GameState};
 
-/// Height of the game board. It must never depend on the spin result, or an
-/// in-place redraw would move to the wrong line.
-pub const SLOT_BOARD_LINES: usize = 7;
+/// Height of the game board. It must never depend on the spin result.
+pub const SLOT_BOARD_LINES: usize = 9;
+pub const LINES: usize = 5;
+pub const REELS: usize = 5;
+pub const ROWS: usize = 3;
 
 pub struct SlotsGame;
 
@@ -11,17 +13,27 @@ impl SlotsGame {
         Self
     }
 
-    fn render_reels(&self, reels: &str) -> String {
-        let mut chars = reels.chars();
-        format!(
-            "[ {} ] [ {} ] [ {} ]",
-            chars.next().unwrap_or('?'),
-            chars.next().unwrap_or('?'),
-            chars.next().unwrap_or('?')
-        )
+    fn cell(chars: &[char], row: usize, col: usize) -> char {
+        if chars.len() == REELS * ROWS {
+            chars.get(col * ROWS + row).copied().unwrap_or('?')
+        } else if chars.len() == 3 && row == 0 {
+            // Legacy 3-symbol server: degrade to the first row.
+            chars.get(col).copied().unwrap_or('?')
+        } else {
+            '?'
+        }
+    }
+
+    fn render_grid(&self, reels: &str) -> [String; ROWS] {
+        let chars: Vec<char> = reels.chars().collect();
+        std::array::from_fn(|row| {
+            (0..REELS)
+                .map(|col| format!("[ {} ]", Self::cell(&chars, row, col)))
+                .collect::<Vec<_>>()
+                .join(" ")
+        })
     }
 
-    /// The fifth board line: current status, result, or error.
     fn render_status(&self, state: &GameState) -> String {
         if let Some(error) = state.data.get("error") {
             return format!("ERROR: {error}");
@@ -35,14 +47,29 @@ impl SlotsGame {
                 .get("winnings")
                 .map(String::as_str)
                 .unwrap_or("0");
-            return match state.data.get("win_type").map(String::as_str) {
-                Some("jackpot") => format!("JACKPOT! Winnings: {winnings} PLN"),
-                Some("two") => format!("Two of a kind! Winnings: {winnings} PLN"),
-                _ => "No win.".to_string(),
-            };
+            if winnings != "0" {
+                return match state.data.get("win_type").map(String::as_str) {
+                    Some("mega") => format!("MEGA WIN! {winnings} PLN"),
+                    Some("big") => format!("BIG WIN! {winnings} PLN"),
+                    _ => format!("Won {winnings} PLN"),
+                };
+            }
+            return "No win.".to_string();
         }
         "Press [SPACE] to spin!".to_string()
     }
+
+    fn render_win_lines(&self, state: &GameState) -> String {
+        if state.phase != GamePhase::Finished {
+            return String::new();
+        }
+        match state.data.get("win_lines").map(String::as_str) {
+            Some(lines) if !lines.is_empty() && lines != "-" => {
+                format!("Winning lines: {lines}")
+            }
+            _ => String::new(),
+        }
+    }
 }
 
 impl Game for SlotsGame {
@@ -57,13 +84,18 @@ impl Game for SlotsGame {
             .get("balance")
             .map(String::as_str)
             .unwrap_or("?");
+        let grid = self.render_grid(&reels);
 
         format!(
-            "=== SLOTS ===\r\nBet: {} PLN   Balance: {} PLN\r\n{}\r\n\r\n{}\r\n\r\n[+/-] Adjust Bet   [Q] Quit",
+            "=== SLOTS ===\r\nBet: {} PLN   Lines: {}   Balance: {} PLN\r\n{}\r\n{}\r\n{}\r\n\r\n{}\r\n{}\r\n[+/-] Bet   [SPACE] Spin   [Q] Quit",
             state.bet_amount,
+            LINES,
             balance,
-            self.render_reels(&reels),
-            self.render_status(state)
+            grid[0],
+            grid[1],
+            grid[2],
+            self.render_status(state),
+            self.render_win_lines(state)
         )
     }
 
@@ -74,17 +106,22 @@ impl Game for SlotsGame {
     fn get_help(&self) -> String {
         "SLOTS GAME\n\
         =========\n\
-        Match symbols to win!\n\
+        5 reels x 3 rows, 5 paylines.\n\
+        Match 3, 4 or 5 symbols from the left on a payline.\n\
         \n\
-        Payouts:\n\
-        Three of a kind: 2x-28x bet\n\
-        Two of a kind: 1x-3x bet\n\
+        Payouts (x total bet, 3/4/5 of a kind):\n\
+        C: 2 / 5 / 15\n\
+        L: 3 / 7 / 20\n\
+        O: 3 / 8 / 25\n\
+        G: 4 / 12 / 40\n\
+        D: 6 / 18 / 70\n\
+        S: 9 / 30 / 150\n\
         \n\
         Symbols: C=Cherry, L=Lemon, O=Orange, G=Grapes, D=Diamond, S=Seven\n\
         \n\
         Controls:\n\
         SPACE - Spin the reels\n\
-        +/- - Adjust bet amount\n\
+        +/- - Adjust total bet\n\
         Q - Exit the game"
             .to_string()
     }
diff --git a/src/server/core.rs b/src/server/core.rs
index 84ad4d2..33cafbf 100644
--- a/src/server/core.rs
+++ b/src/server/core.rs
@@ -239,12 +239,21 @@ impl ServerCore {
             }
         };
 
-        let reels = new_state.data.get("reels").cloned().unwrap_or_default();
-        let win_type = new_state
-            .data
+        let reels = result
+            .result_data
+            .get("reels")
+            .cloned()
+            .unwrap_or_default();
+        let win_type = result
+            .result_data
             .get("win_type")
             .cloned()
             .unwrap_or_default();
+        let win_lines = result
+            .result_data
+            .get("win_lines")
+            .cloned()
+            .unwrap_or_else(|| "-".to_string());
 
         match database::apply_spin(
             &mut self.conn,
@@ -259,7 +268,7 @@ impl ServerCore {
             Ok(new_balance) => {
                 let _ = self.sessions.remove_session(&session_id);
                 format!(
-                    "GAME_RESULT {session_id} {winnings} {bet_amount} {new_balance} {reels} {win_type}"
+                    "GAME_RESULT {session_id} {winnings} {bet_amount} {new_balance} {reels} {win_type} {win_lines}"
                 )
             }
             Err(error) => {
diff --git a/src/server/games/slots.rs b/src/server/games/slots.rs
index 02595b1..2ef1b46 100644
--- a/src/server/games/slots.rs
+++ b/src/server/games/slots.rs
@@ -2,77 +2,127 @@ use super::traits::{Game, GameError, GamePhase, GameResult, GameState};
 use rand::Rng;
 use std::collections::HashMap;
 
+pub const REELS: usize = 5;
+pub const ROWS: usize = 3;
+pub const SYMBOLS: [char; 6] = ['C', 'L', 'O', 'G', 'D', 'S'];
+
+/// Five paylines, each entry is the row used on reel 0..4.
+pub const PAYLINES: [[usize; REELS]; 5] = [
+    [0, 0, 0, 0, 0], // line 1: top
+    [1, 1, 1, 1, 1], // line 2: middle
+    [2, 2, 2, 2, 2], // line 3: bottom
+    [0, 1, 2, 1, 0], // line 4: V
+    [2, 1, 0, 1, 2], // line 5: inverted V
+];
+
+#[derive(Clone, Copy)]
+struct Payout {
+    three: u64,
+    four: u64,
+    five: u64,
+}
+
 pub struct SlotsGame {
-    symbols: Vec<char>,
-    payouts: HashMap<String, u64>,
-    /// Deterministic reels for tests and demos.
-    fixed_reels: Option<Vec<char>>,
+    payouts: HashMap<char, Payout>,
+    /// Deterministic grid for tests and demos, in column-major order.
+    fixed_grid: Option<Vec<char>>,
 }
 
 impl SlotsGame {
     pub fn new() -> Self {
-        let symbols = vec!['C', 'L', 'O', 'G', 'D', 'S'];
         let mut payouts = HashMap::new();
 
-        // Balanced payouts: EV = 210/216 ≈ 0.972 (2.8% house edge)
-        payouts.insert("CCC".to_string(), 2);
-        payouts.insert("LLL".to_string(), 3);
-        payouts.insert("OOO".to_string(), 5);
-        payouts.insert("GGG".to_string(), 8);
-        payouts.insert("DDD".to_string(), 14);
-        payouts.insert("SSS".to_string(), 28);
-
-        payouts.insert("CC".to_string(), 1);
-        payouts.insert("LL".to_string(), 1);
-        payouts.insert("OO".to_string(), 1);
-        payouts.insert("GG".to_string(), 2);
-        payouts.insert("DD".to_string(), 2);
-        payouts.insert("SS".to_string(), 3);
+        // RTP = 425/432 = 0.9838 (1.62% house edge) with five paylines.
+        payouts.insert('C', Payout { three: 2, four: 5, five: 15 });
+        payouts.insert('L', Payout { three: 3, four: 7, five: 20 });
+        payouts.insert('O', Payout { three: 3, four: 8, five: 25 });
+        payouts.insert('G', Payout { three: 4, four: 12, five: 40 });
+        payouts.insert('D', Payout { three: 6, four: 18, five: 70 });
+        payouts.insert('S', Payout { three: 9, four: 30, five: 150 });
 
         Self {
-            symbols,
             payouts,
-            fixed_reels: None,
+            fixed_grid: None,
         }
     }
 
-    /// Build a slots game that always spins the given three symbols.
-    pub fn with_reels(reels: &str) -> Self {
+    /// Build a slots game that always spins the given 15-symbol grid.
+    /// The string is column-major: reel 0 top/middle/bottom, then reel 1...
+    pub fn with_grid(grid: &str) -> Self {
         let mut game = Self::new();
-        game.fixed_reels = Some(reels.chars().take(3).collect());
+        game.fixed_grid = Some(grid.chars().take(REELS * ROWS).collect());
         game
     }
 
-    fn spin_reels(&self) -> Vec<char> {
-        if let Some(reels) = &self.fixed_reels {
-            return reels.clone();
+    fn spin_grid(&self) -> Vec<char> {
+        if let Some(grid) = &self.fixed_grid {
+            return grid.clone();
         }
 
         let mut rng = rand::thread_rng();
-        (0..3)
-            .map(|_| self.symbols[rng.gen_range(0..self.symbols.len())])
+        (0..REELS * ROWS)
+            .map(|_| SYMBOLS[rng.gen_range(0..SYMBOLS.len())])
             .collect()
     }
 
-    pub fn calculate_payout(&self, reels: &[char], bet: u64) -> u64 {
-        let reel_string: String = reels.iter().collect();
-
-        if let Some(&multiplier) = self.payouts.get(&reel_string) {
-            return bet.saturating_mul(multiplier);
-        }
-
-        // Check all three pairs including non-adjacent (e.g. [C,D,C])
-        let pairs: [(usize, usize); 3] = [(0, 1), (1, 2), (0, 2)];
-        let mut best: u64 = 0;
-        for &(a, b) in &pairs {
-            if reels[a] == reels[b] {
-                let two_of_kind = format!("{}{}", reels[a], reels[a]);
-                if let Some(&multiplier) = self.payouts.get(&two_of_kind) {
-                    best = best.max(bet.saturating_mul(multiplier));
+    /// Evaluate one spin. Returns the total win and the 1-based winning lines.
+    pub fn calculate_payout(&self, grid: &[char], bet: u64) -> (u64, Vec<usize>) {
+        let mut total = 0u64;
+        let mut winning_lines = Vec::new();
+
+        for (index, pattern) in PAYLINES.iter().enumerate() {
+            let Some(&first) = grid.get(pattern[0]) else {
+                continue;
+            };
+
+            let mut run = 1;
+            for (col, row) in pattern.iter().enumerate().skip(1) {
+                let position = col * ROWS + row;
+                if grid.get(position) == Some(&first) {
+                    run += 1;
+                } else {
+                    break;
                 }
             }
+
+            if run < 3 {
+                continue;
+            }
+
+            let Some(payout) = self.payouts.get(&first) else {
+                continue;
+            };
+            let multiplier = match run {
+                3 => payout.three,
+                4 => payout.four,
+                _ => payout.five,
+            };
+
+            total = total.saturating_add(bet.saturating_mul(multiplier));
+            winning_lines.push(index + 1);
         }
-        best
+
+        (total, winning_lines)
+    }
+
+    /// Exact theoretical return to player for the current paytable.
+    pub fn theoretical_rtp(&self) -> f64 {
+        // For one reel line and one symbol: exactly 3, 4 or 5 of a kind.
+        let p3 = 5.0 / 1296.0;
+        let p4 = 5.0 / 7776.0;
+        let p5 = 1.0 / 7776.0;
+
+        let per_line: f64 = self
+            .payouts
+            .values()
+            .map(|payout| {
+                p3 * payout.three as f64
+                    + p4 * payout.four as f64
+                    + p5 * payout.five as f64
+            })
+            .sum();
+
+        per_line * PAYLINES.len() as f64
     }
 }
 
@@ -86,7 +136,7 @@ impl Game for SlotsGame {
     }
 
     fn get_description(&self) -> &'static str {
-        "Spin the reels and match symbols to win!"
+        "5 reels x 3 rows, 5 paylines. Match 3, 4 or 5 symbols from the left."
     }
 
     fn prepare_state(&self, username: &str, bet_amount: u64) -> GameState {
@@ -115,32 +165,21 @@ impl Game for SlotsGame {
 
         match action {
             "spin" => {
-                if state.phase != GamePhase::WaitingToStart && state.phase != GamePhase::Playing {
+                if state.phase != GamePhase::WaitingToStart
+                    && state.phase != GamePhase::Playing
+                {
                     return Err(GameError::InvalidAction(
                         "Cannot spin in current phase".to_string(),
                     ));
                 }
 
-                let reels = self.spin_reels();
-                let reel_string: String = reels.iter().collect();
+                let grid = self.spin_grid();
+                let reels: String = grid.iter().collect();
 
                 let mut new_data = state.data.clone();
-                new_data.insert("reels".to_string(), reel_string.clone());
+                new_data.insert("reels".to_string(), reels);
                 new_data.insert("status".to_string(), "spun".to_string());
 
-                let is_jackpot = reels[0] == reels[1] && reels[1] == reels[2];
-                let is_two = reels[0] == reels[1] || reels[1] == reels[2] || reels[0] == reels[2];
-                new_data.insert(
-                    "win_type".to_string(),
-                    if is_jackpot {
-                        "jackpot".to_string()
-                    } else if is_two {
-                        "two".to_string()
-                    } else {
-                        "none".to_string()
-                    },
-                );
-
                 Ok(GameState {
                     session_id: state.session_id.clone(),
                     game_type: state.game_type.clone(),
@@ -165,24 +204,31 @@ impl Game for SlotsGame {
             .data
             .get("reels")
             .ok_or(GameError::InternalError("No reels found".to_string()))?;
+        let grid: Vec<char> = reel_string.chars().collect();
+        if grid.len() != REELS * ROWS {
+            return Err(GameError::InternalError(format!(
+                "Expected {} symbols, got {}",
+                REELS * ROWS,
+                grid.len()
+            )));
+        }
 
-        let reels: Vec<char> = reel_string.chars().collect();
-        let winnings = self.calculate_payout(&reels, state.bet_amount);
+        let (winnings, winning_lines) = self.calculate_payout(&grid, state.bet_amount);
+        let win_type = classify_win(winnings, state.bet_amount);
+        let win_lines = if winning_lines.is_empty() {
+            "-".to_string()
+        } else {
+            winning_lines
+                .iter()
+                .map(usize::to_string)
+                .collect::<Vec<_>>()
+                .join(",")
+        };
 
         let mut result_data = HashMap::new();
         result_data.insert("reels".to_string(), reel_string.clone());
-        result_data.insert(
-            "payout_multiplier".to_string(),
-            if winnings > 0 && state.bet_amount > 0 {
-                (winnings / state.bet_amount).to_string()
-            } else {
-                "0".to_string()
-            },
-        );
-        result_data.insert(
-            "win_type".to_string(),
-            state.data.get("win_type").cloned().unwrap_or_default(),
-        );
+        result_data.insert("win_type".to_string(), win_type.to_string());
+        result_data.insert("win_lines".to_string(), win_lines);
 
         Ok(GameResult {
             session_id: state.session_id.clone(),
@@ -194,3 +240,15 @@ impl Game for SlotsGame {
         })
     }
 }
+
+fn classify_win(winnings: u64, bet: u64) -> &'static str {
+    if winnings == 0 {
+        "none"
+    } else if bet > 0 && winnings >= bet.saturating_mul(50) {
+        "mega"
+    } else if bet > 0 && winnings >= bet.saturating_mul(10) {
+        "big"
+    } else {
+        "win"
+    }
+}