v3.0.0: cursor-driven roulette felt with splits and corners; drop schema migrations; require 80x24

1 files changed, 24 insertions, 78 deletions

diff --git a/src/client/core.rs b/src/client/core.rs
index 06d9c42..8411d47 100644
--- a/src/client/core.rs
+++ b/src/client/core.rs
@@ -7,7 +7,8 @@ use crate::client::ui::{
     record_history,
 };
 use crate::crash::{multiplier_at, CrashState};
-use crate::roulette::{Bets, NumberBet};
+use crate::client::games::roulette::Direction;
+use crate::roulette::Bets;
 use std::time::{Duration, Instant};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -17,6 +18,8 @@ pub enum Key {
     Backspace,
     Up,
     Down,
+    Left,
+    Right,
     Tab,
     Esc,
     CtrlC,
@@ -76,14 +79,6 @@ enum Pending {
     Info,
 }
 
-#[derive(Debug, Clone, Copy)]
-enum RouletteSide {
-    Red,
-    Black,
-    Even,
-    Odd,
-}
-
 pub struct ClientCore {
     input: String,
     history: Vec<String>,
@@ -171,6 +166,7 @@ impl ClientCore {
             }
             Key::Up => self.history_previous(),
             Key::Down => self.history_next(),
+            Key::Left | Key::Right => Vec::new(),
             Key::Tab => self.complete(),
             Key::Esc => Vec::new(),
         }
@@ -355,6 +351,19 @@ impl ClientCore {
     }
 
     fn handle_roulette_key(&mut self, key: Key) -> Vec<Effect> {
+        let direction = match key {
+            Key::Up => Some(Direction::Up),
+            Key::Down => Some(Direction::Down),
+            Key::Left => Some(Direction::Left),
+            Key::Right => Some(Direction::Right),
+            _ => None,
+        };
+        if let Some(direction) = direction {
+            let cursor = self.game.roulette_cursor().moved(direction);
+            self.game.set_roulette_cursor(&cursor);
+            return self.board_effects();
+        }
+
         match key {
             Key::CtrlC => vec![Effect::Quit],
             Key::Char('q') => {
@@ -364,18 +373,9 @@ impl ClientCore {
                     Effect::Print(vec!["Game exited.".to_string()]),
                 ]
             }
-            Key::Esc => {
-                self.game.set_roulette_number_input("");
-                self.board_effects()
-            }
             Key::Char(' ') => self.spin_roulette(),
-            Key::Char('r') => self.add_roulette_side(RouletteSide::Red),
-            Key::Char('b') => self.add_roulette_side(RouletteSide::Black),
-            Key::Char('e') => self.add_roulette_side(RouletteSide::Even),
-            Key::Char('o') => self.add_roulette_side(RouletteSide::Odd),
             Key::Char('c') => {
                 self.game.set_roulette_bets(&Bets::default());
-                self.game.set_roulette_number_input("");
                 self.game.set_roulette_status("place");
                 self.board_effects()
             }
@@ -389,63 +389,17 @@ impl ClientCore {
                 self.game.set_roulette_chip(chip);
                 self.board_effects()
             }
-            Key::Char(c) if c.is_ascii_digit() => {
-                let mut input = self.roulette_input();
-                if input.len() < 2 {
-                    input.push(c);
-                    self.game.set_roulette_number_input(&input);
-                }
-                self.board_effects()
-            }
-            Key::Backspace => {
-                let mut input = self.roulette_input();
-                input.pop();
-                self.game.set_roulette_number_input(&input);
-                self.board_effects()
-            }
-            Key::Enter => {
-                let input = self.roulette_input();
-                if !input.is_empty() {
-                    match input.parse::<u8>() {
-                        Ok(number) if number <= 36 => {
-                            self.add_roulette_number(number);
-                            self.game.set_roulette_number_input("");
-                        }
-                        _ => {
-                            self.game.set_roulette_number_input("");
-                            self.game.set_error("Number must be 0-36");
-                        }
-                    }
-                }
-                self.board_effects()
-            }
+            Key::Enter => self.place_roulette_chip(),
             _ => Vec::new(),
         }
     }
 
-    fn add_roulette_side(&mut self, side: RouletteSide) -> Vec<Effect> {
-        let chip = self.game.roulette_chip();
-        let mut bets = self.game.roulette_bets();
-        match side {
-            RouletteSide::Red => bets.red = bets.red.saturating_add(chip),
-            RouletteSide::Black => bets.black = bets.black.saturating_add(chip),
-            RouletteSide::Even => bets.even = bets.even.saturating_add(chip),
-            RouletteSide::Odd => bets.odd = bets.odd.saturating_add(chip),
-        }
-        self.place_roulette_bets(bets)
-    }
-
-    fn add_roulette_number(&mut self, number: u8) -> Vec<Effect> {
-        let chip = self.game.roulette_chip();
+    fn place_roulette_chip(&mut self) -> Vec<Effect> {
+        let Some(target) = self.game.roulette_cursor().target() else {
+            return Vec::new();
+        };
         let mut bets = self.game.roulette_bets();
-        if let Some(existing) = bets.numbers.iter_mut().find(|bet| bet.number == number) {
-            existing.amount = existing.amount.saturating_add(chip);
-        } else {
-            bets.numbers.push(NumberBet {
-                number,
-                amount: chip,
-            });
-        }
+        bets.add(target, self.game.roulette_chip());
         self.place_roulette_bets(bets)
     }
 
@@ -487,14 +441,6 @@ impl ClientCore {
         effects
     }
 
-    fn roulette_input(&self) -> String {
-        self.game
-            .get_current_state()
-            .and_then(|state| state.data.get("number_input"))
-            .cloned()
-            .unwrap_or_default()
-    }
-
     fn handle_blackjack_key(&mut self, key: Key) -> Vec<Effect> {
         let status = self
             .game