v4.2.0: wire the GUI to the core, transport and all four games

Phase 4. The egui frontend now shares ClientCore and the client database with the terminal: one background worker owns TLS, trust answers go through a channel, and a 10 s request deadline mirrors the terminal socket timeout. First contact, a changed key and a version mismatch are explicit screens; login can remember the credential and auto-login signs in before the login form appears.

Adds the lobby with an update notice, a full-width scrollable history table, and the four games painted from View: slots with reel animation and win lines that stop at the last matching reel, roulette with the hover lattice and wheel spin, blackjack with vector-drawn suits, and a smooth crash curve. Sidebars pin their action block; leaving a live hand or round asks before forfeiting.

The header balance holds the staked amount while the reels or wheel turn and only shows the payout when they stop. Refused spins cancel the animation. Live crash multipliers keep full precision for the chart; the terminal still displays two decimals.

Verified live against a 4.2.0 server: register, login, auto-login, trust, all four games settling, history (50 rows), logout, disconnect, forfeit confirmation, and the version-mismatch screen. Release: 8.3 MB Linux, 6.8 MB Windows, 61 ms to window, 131 MB idle RSS.

1 files changed, 416 insertions, 0 deletions

diff --git a/gui/src/crash.rs b/gui/src/crash.rs
new file mode 100644
index 0000000..14197ae
--- /dev/null
+++ b/gui/src/crash.rs
@@ -0,0 +1,416 @@
+//! Crash screen: a live multiplier painted from `CrashView`.
+
+use eframe::egui::{Align2, Color32, Pos2, Rect, Sense, Shape, Stroke, StrokeKind, Ui, pos2, vec2};
+use zagan_bet::client::view::{Command, CrashView};
+
+use crate::{theme, widgets};
+
+/// One sample of the running curve.
+struct Sample {
+    seconds: f32,
+    multiplier: f64,
+}
+
+#[derive(Default)]
+pub struct Fx {
+    points: Vec<Sample>,
+    started: Option<f64>,
+    status: String,
+    peak: f64,
+    last_crash: Option<f64>,
+}
+
+impl Fx {
+    pub fn tick(&mut self, ctx: &eframe::egui::Context, view: &CrashView) {
+        let now = ctx.input(|input| input.time);
+
+        if view.status == "starting" && self.status != "starting" {
+            self.points.clear();
+            self.started = None;
+            self.peak = 1.0;
+        }
+
+        if view.status == "running" {
+            let started = *self.started.get_or_insert(now);
+            let seconds = (now - started) as f32;
+            let last = self.points.last().map(|sample| sample.seconds);
+            if last.is_none_or(|last| seconds - last >= 0.016) {
+                self.points.push(Sample {
+                    seconds,
+                    multiplier: view.multiplier,
+                });
+                self.peak = self.peak.max(view.multiplier);
+            }
+            ctx.request_repaint_after(std::time::Duration::from_millis(16));
+        } else if view.status == "starting" {
+            ctx.request_repaint_after(std::time::Duration::from_millis(50));
+        }
+
+        if view.status == "crashed" {
+            if let Some(point) = view.crash_point {
+                self.last_crash = Some(point);
+            }
+        }
+        if view.status != self.status {
+            self.status = view.status.clone();
+        }
+    }
+
+    fn reset(&mut self) {
+        self.points.clear();
+        self.started = None;
+        self.peak = 1.0;
+    }
+}
+
+pub fn show(ui: &mut Ui, view: &CrashView, fx: &mut Fx) -> Option<Command> {
+    let mut command = None;
+    eframe::egui::CentralPanel::default()
+        .frame(eframe::egui::Frame::new().fill(theme::BG))
+        .show(ui, |ui| {
+            let full = ui.max_rect();
+            let sidebar_rect = eframe::egui::Rect::from_min_max(
+                eframe::egui::pos2(full.right() - 336.0, full.top()),
+                full.right_bottom(),
+            );
+            let board_rect = eframe::egui::Rect::from_min_max(
+                full.min,
+                eframe::egui::pos2(sidebar_rect.left(), full.bottom()),
+            );
+            ui.painter().rect_filled(
+                sidebar_rect,
+                eframe::egui::CornerRadius::ZERO,
+                theme::SURFACE,
+            );
+            ui.scope_builder(
+                eframe::egui::UiBuilder::new()
+                    .max_rect(board_rect.shrink2(eframe::egui::vec2(24.0, 24.0)))
+                    .layout(eframe::egui::Layout::top_down(eframe::egui::Align::Min)),
+                |ui| chart(ui, view, fx),
+            );
+            ui.scope_builder(
+                eframe::egui::UiBuilder::new()
+                    .max_rect(sidebar_rect.shrink2(eframe::egui::vec2(24.0, 20.0)))
+                    .layout(eframe::egui::Layout::top_down(eframe::egui::Align::Min)),
+                |ui| {
+                    command = sidebar(ui, view, fx);
+                },
+            );
+        });
+    command
+}
+
+fn sidebar(ui: &mut Ui, view: &CrashView, fx: &mut Fx) -> Option<Command> {
+    let mut command = None;
+    let running = view.status == "running";
+    let starting = view.status == "starting";
+    let (content, actions) = widgets::sidebar_layout(ui, 130.0);
+
+    ui.scope_builder(
+        eframe::egui::UiBuilder::new()
+            .max_rect(content)
+            .layout(eframe::egui::Layout::top_down(eframe::egui::Align::Min)),
+        |ui| {
+            eframe::egui::ScrollArea::vertical()
+                .auto_shrink([false, false])
+                .show(ui, |ui| {
+                    ui.label(
+                        eframe::egui::RichText::new("Crash")
+                            .font(theme::sans(22.0))
+                            .color(theme::TEXT),
+                    );
+                    ui.label(
+                        eframe::egui::RichText::new("Rise  ·  cash out  ·  don't bust")
+                            .font(theme::sans(12.0))
+                            .color(theme::TEXT_DIM),
+                    );
+
+                    ui.add_space(theme::SPACE_5);
+                    ui.label(theme::label("Bet"));
+                    ui.add_space(theme::SPACE_2);
+                    if let Some(delta) = widgets::bet_control(ui, view.bet, !running && !starting) {
+                        command = Some(Command::AdjustBet(delta));
+                    }
+
+                    ui.add_space(theme::SPACE_4);
+                    widgets::row(
+                        ui,
+                        "Potential",
+                        &theme::money(view.potential as i64),
+                        theme::GOLD,
+                    );
+
+                    ui.add_space(theme::SPACE_3);
+                    status(ui, view);
+
+                    if let Some(point) = fx.last_crash {
+                        ui.add_space(theme::SPACE_2);
+                        widgets::row(ui, "Last crash", &format!("{point:.2}x"), theme::TEXT_DIM);
+                    }
+
+                    if let Some(error) = &view.error {
+                        ui.add_space(theme::SPACE_3);
+                        widgets::error(ui, error);
+                    }
+
+                    ui.add_space(theme::SPACE_4);
+                    ui.separator();
+                    ui.add_space(theme::SPACE_2);
+                    widgets::note(
+                        ui,
+                        "The crash point is server-timed. The curve here is display only.",
+                    );
+                });
+        },
+    );
+
+    ui.scope_builder(
+        eframe::egui::UiBuilder::new()
+            .max_rect(actions)
+            .layout(eframe::egui::Layout::bottom_up(eframe::egui::Align::Min)),
+        |ui| {
+            if widgets::ghost(
+                ui,
+                if running {
+                    "Forfeit round"
+                } else {
+                    "Leave table"
+                },
+            ) {
+                command = Some(Command::Leave);
+            }
+            ui.add_space(theme::SPACE_2);
+            if running {
+                if widgets::primary(ui, "CASH OUT", true, ui.available_width(), 46.0) {
+                    command = Some(Command::CashOut);
+                }
+            } else if !starting && widgets::primary(ui, "START", true, ui.available_width(), 46.0) {
+                fx.reset();
+                command = Some(Command::Start);
+            }
+        },
+    );
+
+    command
+}
+
+fn status(ui: &mut Ui, view: &CrashView) {
+    match view.status.as_str() {
+        "starting" => widgets::note(ui, "Round starting…"),
+        "running" => widgets::note(ui, "Rising. Cash out before it crashes."),
+        "cashed" => {
+            ui.label(
+                eframe::egui::RichText::new(format!(
+                    "CASHED OUT  {:.2}x   +{}",
+                    view.multiplier,
+                    theme::money(view.payout as i64)
+                ))
+                .font(theme::mono(14.0))
+                .color(theme::WIN),
+            );
+        }
+        "crashed" => {
+            ui.label(
+                eframe::egui::RichText::new(format!(
+                    "CRASHED at {:.2}x",
+                    view.crash_point.unwrap_or(view.multiplier)
+                ))
+                .font(theme::mono(14.0))
+                .color(theme::LOSS),
+            );
+        }
+        "forfeit" => {
+            ui.label(
+                eframe::egui::RichText::new("FORFEITED")
+                    .font(theme::mono(14.0))
+                    .color(theme::TEXT_DIM),
+            );
+        }
+        _ => widgets::note(ui, "Press START to play."),
+    }
+}
+
+fn chart(ui: &mut Ui, view: &CrashView, fx: &Fx) {
+    ui.horizontal(|ui| {
+        ui.label(
+            eframe::egui::RichText::new("Table 01")
+                .font(theme::sans(15.0))
+                .color(theme::TEXT),
+        );
+        ui.label(
+            eframe::egui::RichText::new("Crash  ·  server-timed")
+                .font(theme::sans(12.0))
+                .color(theme::TEXT_DIM),
+        );
+        ui.with_layout(
+            eframe::egui::Layout::right_to_left(eframe::egui::Align::Center),
+            |ui| {
+                ui.label(
+                    eframe::egui::RichText::new("Cash out any time before the crash")
+                        .font(theme::mono(11.0))
+                        .color(theme::TEXT_FAINT),
+                );
+            },
+        );
+    });
+    ui.add_space(theme::SPACE_4);
+
+    let available = ui.available_size();
+    let size = vec2(available.x, (available.y - 70.0).max(260.0));
+    let (rect, _) = ui.allocate_exact_size(size, Sense::hover());
+    let painter = ui.painter();
+
+    painter.rect_filled(rect, theme::RADIUS_LG, theme::SURFACE);
+    painter.rect_stroke(
+        rect,
+        theme::RADIUS_LG,
+        Stroke::new(1.0, theme::LINE),
+        StrokeKind::Inside,
+    );
+
+    let plot = rect.shrink2(vec2(56.0, 48.0));
+    let max_seconds = fx
+        .points
+        .last()
+        .map(|sample| sample.seconds)
+        .unwrap_or(0.0)
+        .max(6.0)
+        * 1.08;
+    let max_multiplier = fx.peak.max(2.0) * 1.15;
+
+    painter.text(
+        plot.left_top() + vec2(0.0, 2.0),
+        Align2::LEFT_TOP,
+        format!("{:.2}x", view.multiplier),
+        theme::mono(46.0),
+        curve_color(view),
+    );
+    painter.text(
+        plot.left_top() + vec2(2.0, 58.0),
+        Align2::LEFT_TOP,
+        status_label(view),
+        theme::mono(10.0),
+        theme::TEXT_FAINT,
+    );
+
+    // Grid: whole multipliers and two-second columns.
+    let grid = Stroke::new(1.0, theme::LINE.gamma_multiply(0.55));
+    let mut step = 1.0;
+    while max_multiplier / step > 6.0 {
+        step += 1.0;
+    }
+    let mut value = step;
+    while value <= max_multiplier {
+        let y = map_y(plot, value, max_multiplier);
+        painter.hline(plot.x_range(), y, grid);
+        painter.text(
+            pos2(plot.left() - 10.0, y),
+            Align2::RIGHT_CENTER,
+            format!("{value:.0}x"),
+            theme::mono(10.0),
+            theme::TEXT_FAINT,
+        );
+        value += step;
+    }
+    let mut second = 2.0;
+    while f64::from(second) <= f64::from(max_seconds) {
+        let x = plot.left() + plot.width() * (second / max_seconds);
+        painter.vline(x, plot.y_range(), grid);
+        painter.text(
+            pos2(x, plot.bottom() + 8.0),
+            Align2::CENTER_TOP,
+            format!("{second:.0}s"),
+            theme::mono(10.0),
+            theme::TEXT_FAINT,
+        );
+        second += 2.0;
+    }
+
+    if fx.points.is_empty() {
+        painter.text(
+            plot.center(),
+            Align2::CENTER_CENTER,
+            if view.status == "running" {
+                "…"
+            } else {
+                "Press START to play"
+            },
+            theme::sans(14.0),
+            theme::TEXT_FAINT,
+        );
+    } else {
+        let points: Vec<Pos2> = fx
+            .points
+            .iter()
+            .map(|sample| {
+                pos2(
+                    plot.left() + plot.width() * (sample.seconds / max_seconds),
+                    map_y(plot, sample.multiplier, max_multiplier),
+                )
+            })
+            .collect();
+
+        // A soft fill under the curve.
+        if points.len() >= 2 {
+            let mut fill = points.clone();
+            fill.push(pos2(points[points.len() - 1].x, plot.bottom()));
+            fill.push(pos2(points[0].x, plot.bottom()));
+            painter.add(Shape::convex_polygon(
+                fill,
+                curve_color(view).gamma_multiply(0.10),
+                Stroke::NONE,
+            ));
+        }
+        painter.add(Shape::line(points, Stroke::new(2.5, curve_color(view))));
+
+        if view.status == "crashed" {
+            if let Some(point) = view.crash_point {
+                let y = map_y(plot, point, max_multiplier);
+                let x = plot.left()
+                    + plot.width() * (fx.points.last().map_or(0.0, |s| s.seconds) / max_seconds);
+                painter.circle_filled(pos2(x, y), 5.0, theme::LOSS);
+                painter.text(
+                    pos2(x + 10.0, y - 8.0),
+                    Align2::LEFT_BOTTOM,
+                    format!("{point:.2}x"),
+                    theme::mono(12.0),
+                    theme::LOSS,
+                );
+            }
+        }
+    }
+
+    ui.add_space(theme::SPACE_4);
+    ui.label(
+        eframe::egui::RichText::new(
+            "The crash point is drawn from the server; the multiplier here is display only.",
+        )
+        .font(theme::sans(11.0))
+        .color(theme::TEXT_FAINT),
+    );
+}
+
+fn map_y(plot: Rect, multiplier: f64, max_multiplier: f64) -> f32 {
+    let range = (max_multiplier - 1.0).max(0.1);
+    plot.bottom() - ((multiplier - 1.0) / range) as f32 * plot.height()
+}
+
+fn status_label(view: &CrashView) -> &'static str {
+    match view.status.as_str() {
+        "starting" => "STARTING",
+        "running" => "LIVE",
+        "cashed" => "CASHED OUT",
+        "crashed" => "CRASHED",
+        "forfeit" => "FORFEITED",
+        _ => "READY",
+    }
+}
+
+fn curve_color(view: &CrashView) -> Color32 {
+    match view.status.as_str() {
+        "running" => theme::WIN,
+        "cashed" => theme::GOLD,
+        "crashed" => theme::LOSS,
+        _ => theme::TEXT_DIM,
+    }
+}