Add pressure visual modes and breakout game

src/breakout.rs

@@ -0,0 +1,643 @@
+use eframe::egui;
+
+use crate::style::{self, ACCENT_BLUE, ACCENT_GREEN, ACCENT_ORANGE, ACCENT_RED, ONE_DARK_PRO};
+
+const BRICK_ROWS: usize = 7;
+const BRICK_COLS: usize = 12;
+const PADDLE_W: f32 = 0.24;
+const PADDLE_H: f32 = 0.030;
+const PADDLE_Y: f32 = 0.88;
+const PADDLE_SPEED: f32 = 0.92;
+const BALL_RADIUS: f32 = 0.010;
+const BALL_SPEED: f32 = 0.52;
+const MAX_BALL_SPEED: f32 = 0.86;
+const PRESSURE_RANGE_MIN: f32 = 0.0;
+const PRESSURE_RANGE_MAX: f32 = 7000.0;
+const PAUSE_COOLDOWN: f64 = 0.64;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum BreakoutPhase {
+    Idle,
+    Running,
+    Paused,
+    Over,
+}
+
+struct Brick {
+    rect: egui::Rect,
+    alive: bool,
+    flash: f32,
+}
+
+#[derive(Default, Clone, Copy)]
+pub struct BreakoutControl {
+    pub axis: f32,
+    pub top_force: f32,
+    pub left_force: f32,
+    pub right_force: f32,
+}
+
+pub struct BreakoutGame {
+    phase: BreakoutPhase,
+    bricks: Vec<Brick>,
+    paddle_x: f32,
+    ball_pos: egui::Pos2,
+    ball_vel: egui::Vec2,
+    score: u32,
+    combo: u32,
+    lives: u32,
+    level: u32,
+    last_time: Option<f64>,
+    previous_pause_gesture: bool,
+    pause_locked_until: f64,
+}
+
+impl Default for BreakoutGame {
+    fn default() -> Self {
+        let mut game = Self {
+            phase: BreakoutPhase::Idle,
+            bricks: Vec::new(),
+            paddle_x: 0.5,
+            ball_pos: egui::pos2(0.5, PADDLE_Y - PADDLE_H - BALL_RADIUS),
+            ball_vel: egui::vec2(0.0, 0.0),
+            score: 0,
+            combo: 0,
+            lives: 3,
+            level: 1,
+            last_time: None,
+            previous_pause_gesture: false,
+            pause_locked_until: 0.0,
+        };
+        game.rebuild_bricks();
+        game
+    }
+}
+
+impl BreakoutGame {
+    pub fn draw_viewport(
+        &mut self,
+        ctx: &egui::Context,
+        rect: egui::Rect,
+        visible: &mut bool,
+        control: BreakoutControl,
+    ) {
+        if !*visible {
+            self.last_time = None;
+            return;
+        }
+
+        ctx.request_repaint();
+        let now = ctx.input(|input| input.time);
+        let dt = self
+            .last_time
+            .map(|last| (now - last) as f32)
+            .unwrap_or(1.0 / 60.0)
+            .clamp(0.0, 1.0 / 30.0);
+        self.last_time = Some(now);
+
+        let mut close_requested = false;
+        egui::Area::new(egui::Id::new("breakout_game_viewport"))
+            .fixed_pos(rect.min)
+            .order(egui::Order::Middle)
+            .show(ctx, |ui| {
+                ui.set_min_size(rect.size());
+                ui.set_max_size(rect.size());
+                style::group_frame().show(ui, |ui| {
+                    ui.set_min_size(rect.size() - egui::vec2(20.0, 16.0));
+                    if self.draw_contents(ui, control, dt, now, true) {
+                        close_requested = true;
+                    }
+                });
+            });
+
+        if close_requested {
+            *visible = false;
+        }
+    }
+
+    fn draw_contents(
+        &mut self,
+        ui: &mut egui::Ui,
+        control: BreakoutControl,
+        dt: f32,
+        now: f64,
+        embedded: bool,
+    ) -> bool {
+        let mut close_requested = false;
+        ui.horizontal(|ui| {
+            ui.colored_label(
+                ACCENT_BLUE,
+                egui::RichText::new("NEON BREAKOUT").monospace().size(13.0),
+            );
+            ui.label(style::subtle_text("压力矩阵控制 / 左右分区驱动"));
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if embedded && ui.add(style::tag_button("退出分屏")).clicked() {
+                    close_requested = true;
+                }
+                if ui.add(style::tag_button("重开")).clicked() {
+                    self.reset();
+                    self.start();
+                }
+                if ui.add(style::tag_button("暂停")).clicked() {
+                    self.toggle_pause();
+                }
+            });
+        });
+
+        ui.add_space(5.0);
+        ui.horizontal(|ui| {
+            status_chip(ui, "状态", self.status_text(), status_color(self.phase));
+            status_chip(ui, "分数", self.score.to_string(), ACCENT_GREEN);
+            status_chip(ui, "连击", self.combo.to_string(), ACCENT_ORANGE);
+            status_chip(ui, "生命", self.lives.to_string(), ACCENT_RED);
+            status_chip(ui, "关卡", self.level.to_string(), ACCENT_BLUE);
+        });
+
+        ui.add_space(7.0);
+        let available = ui.available_size();
+        let game_size = egui::vec2(available.x.max(500.0), (available.y - 6.0).max(330.0));
+        let (rect, response) = ui.allocate_exact_size(game_size, egui::Sense::click());
+        if response.clicked() && self.phase != BreakoutPhase::Running {
+            self.start();
+        }
+
+        let keyboard_axis = ui.input(|input| {
+            (input.key_down(egui::Key::ArrowRight) as i32
+                - input.key_down(egui::Key::ArrowLeft) as i32) as f32
+        });
+        if ui.input(|input| input.key_pressed(egui::Key::Space)) {
+            self.start();
+        }
+        if ui.input(|input| input.key_pressed(egui::Key::P)) {
+            self.toggle_pause();
+        }
+
+        let axis = if keyboard_axis.abs() > 0.0 {
+            keyboard_axis
+        } else {
+            control.axis
+        };
+        self.handle_pressure_gesture(control.top_force, now);
+        self.update(dt, axis);
+        self.paint(ui, rect, control);
+        close_requested
+    }
+
+    fn reset(&mut self) {
+        self.phase = BreakoutPhase::Idle;
+        self.paddle_x = 0.5;
+        self.ball_pos = egui::pos2(0.5, PADDLE_Y - PADDLE_H - BALL_RADIUS);
+        self.ball_vel = egui::Vec2::ZERO;
+        self.score = 0;
+        self.combo = 0;
+        self.lives = 3;
+        self.level = 1;
+        self.rebuild_bricks();
+    }
+
+    fn start(&mut self) {
+        if self.phase == BreakoutPhase::Over {
+            self.reset();
+        }
+        if self.phase != BreakoutPhase::Running {
+            self.phase = BreakoutPhase::Running;
+            if self.ball_vel == egui::Vec2::ZERO {
+                self.launch_ball();
+            }
+        }
+    }
+
+    fn toggle_pause(&mut self) {
+        self.phase = match self.phase {
+            BreakoutPhase::Running => BreakoutPhase::Paused,
+            BreakoutPhase::Paused => BreakoutPhase::Running,
+            other => other,
+        };
+    }
+
+    fn handle_pressure_gesture(&mut self, top_force: f32, now: f64) {
+        let threshold = pressure_pause_threshold();
+        let active = top_force >= threshold;
+        if active && !self.previous_pause_gesture && now >= self.pause_locked_until {
+            if self.phase == BreakoutPhase::Idle || self.phase == BreakoutPhase::Over {
+                self.start();
+            } else {
+                self.toggle_pause();
+            }
+            self.pause_locked_until = now + PAUSE_COOLDOWN;
+        }
+        self.previous_pause_gesture = active;
+    }
+
+    fn update(&mut self, dt: f32, axis: f32) {
+        for brick in &mut self.bricks {
+            brick.flash = (brick.flash - dt * 2.4).max(0.0);
+        }
+
+        if self.phase != BreakoutPhase::Running {
+            self.ball_pos = egui::pos2(self.paddle_x, PADDLE_Y - PADDLE_H - BALL_RADIUS);
+            return;
+        }
+
+        self.paddle_x = (self.paddle_x + axis.clamp(-1.0, 1.0) * PADDLE_SPEED * dt)
+            .clamp(PADDLE_W * 0.5, 1.0 - PADDLE_W * 0.5);
+
+        self.ball_pos += self.ball_vel * dt;
+        self.resolve_wall_collision();
+        self.resolve_paddle_collision();
+        self.resolve_brick_collision();
+    }
+
+    fn launch_ball(&mut self) {
+        let direction = if self.level % 2 == 0 { -0.24 } else { 0.24 };
+        self.ball_pos = egui::pos2(self.paddle_x, PADDLE_Y - PADDLE_H - BALL_RADIUS);
+        self.ball_vel = egui::vec2(direction, -1.0).normalized() * BALL_SPEED;
+    }
+
+    fn resolve_wall_collision(&mut self) {
+        if self.ball_pos.x - BALL_RADIUS <= 0.0 {
+            self.ball_pos.x = BALL_RADIUS;
+            self.ball_vel.x = self.ball_vel.x.abs();
+        } else if self.ball_pos.x + BALL_RADIUS >= 1.0 {
+            self.ball_pos.x = 1.0 - BALL_RADIUS;
+            self.ball_vel.x = -self.ball_vel.x.abs();
+        }
+
+        if self.ball_pos.y - BALL_RADIUS <= 0.0 {
+            self.ball_pos.y = BALL_RADIUS;
+            self.ball_vel.y = self.ball_vel.y.abs();
+        }
+
+        if self.ball_pos.y - BALL_RADIUS > 1.0 {
+            self.lives = self.lives.saturating_sub(1);
+            self.combo = 0;
+            if self.lives == 0 {
+                self.phase = BreakoutPhase::Over;
+                self.ball_vel = egui::Vec2::ZERO;
+            } else {
+                self.ball_pos = egui::pos2(self.paddle_x, PADDLE_Y - PADDLE_H - BALL_RADIUS);
+                self.launch_ball();
+            }
+        }
+    }
+
+    fn resolve_paddle_collision(&mut self) {
+        if self.ball_vel.y <= 0.0 {
+            return;
+        }
+
+        let paddle = paddle_rect(self.paddle_x);
+        if !circle_hits_rect(self.ball_pos, BALL_RADIUS, paddle) {
+            return;
+        }
+
+        self.ball_pos.y = paddle.top() - BALL_RADIUS;
+        let offset = ((self.ball_pos.x - self.paddle_x) / (PADDLE_W * 0.5)).clamp(-1.0, 1.0);
+        let speed = self.ball_vel.length().clamp(BALL_SPEED, MAX_BALL_SPEED);
+        self.ball_vel = egui::vec2(offset * 0.82, -1.0).normalized() * speed;
+        self.combo = 0;
+    }
+
+    fn resolve_brick_collision(&mut self) {
+        for brick in &mut self.bricks {
+            if !brick.alive || !circle_hits_rect(self.ball_pos, BALL_RADIUS, brick.rect) {
+                continue;
+            }
+
+            let overlap_x = (self.ball_pos.x + BALL_RADIUS - brick.rect.left())
+                .min(brick.rect.right() - (self.ball_pos.x - BALL_RADIUS));
+            let overlap_y = (self.ball_pos.y + BALL_RADIUS - brick.rect.top())
+                .min(brick.rect.bottom() - (self.ball_pos.y - BALL_RADIUS));
+            if overlap_x < overlap_y {
+                self.ball_vel.x *= -1.0;
+            } else {
+                self.ball_vel.y *= -1.0;
+            }
+
+            brick.alive = false;
+            brick.flash = 1.0;
+            self.combo += 1;
+            self.score += 40 + self.combo * 5;
+            let speed = (self.ball_vel.length() * 1.014).min(MAX_BALL_SPEED);
+            self.ball_vel = self.ball_vel.normalized() * speed;
+            break;
+        }
+
+        if self.bricks.iter().all(|brick| !brick.alive) {
+            self.level += 1;
+            self.rebuild_bricks();
+            self.launch_ball();
+        }
+    }
+
+    fn rebuild_bricks(&mut self) {
+        self.bricks.clear();
+        let gap_x = 0.012;
+        let gap_y = 0.017;
+        let left = 0.075;
+        let top = 0.10;
+        let total_w = 0.85;
+        let brick_w = (total_w - gap_x * (BRICK_COLS - 1) as f32) / BRICK_COLS as f32;
+        let brick_h = 0.040;
+
+        for row in 0..BRICK_ROWS {
+            for col in 0..BRICK_COLS {
+                let x = left + col as f32 * (brick_w + gap_x);
+                let y = top + row as f32 * (brick_h + gap_y);
+                self.bricks.push(Brick {
+                    rect: egui::Rect::from_min_size(egui::pos2(x, y), egui::vec2(brick_w, brick_h)),
+                    alive: true,
+                    flash: 0.0,
+                });
+            }
+        }
+    }
+
+    fn status_text(&self) -> &'static str {
+        match self.phase {
+            BreakoutPhase::Idle => "待机",
+            BreakoutPhase::Running => "运行",
+            BreakoutPhase::Paused => "暂停",
+            BreakoutPhase::Over => "结束",
+        }
+    }
+
+    fn paint(&self, ui: &egui::Ui, rect: egui::Rect, control: BreakoutControl) {
+        let painter = ui.painter_at(rect);
+        painter.rect_filled(
+            rect,
+            egui::CornerRadius::same(6),
+            egui::Color32::from_rgb(8, 14, 19),
+        );
+        painter.rect_stroke(
+            rect,
+            egui::CornerRadius::same(6),
+            egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 110)),
+            egui::StrokeKind::Outside,
+        );
+
+        paint_arena_grid(&painter, rect);
+        for (index, brick) in self.bricks.iter().enumerate() {
+            paint_brick(&painter, rect, brick, index);
+        }
+
+        paint_paddle(&painter, rect, self.paddle_x);
+        paint_ball(&painter, rect, self.ball_pos);
+        paint_control_meter(&painter, rect, control);
+
+        if self.phase == BreakoutPhase::Idle
+            || self.phase == BreakoutPhase::Paused
+            || self.phase == BreakoutPhase::Over
+        {
+            paint_center_overlay(&painter, rect, self.phase);
+        }
+    }
+}
+
+pub fn control_from_matrix(raw: &[u32], rows: u32, cols: u32) -> BreakoutControl {
+    if raw.is_empty() {
+        return BreakoutControl::default();
+    }
+
+    let rows = rows.max(1) as usize;
+    let cols = cols.max(1) as usize;
+    let sample_rows = rows.min(2);
+    let sample_cols = cols.min(2);
+    let avg = |row_start: usize, row_end: usize, col_start: usize, col_end: usize| -> f32 {
+        let mut sum = 0.0;
+        let mut count = 0.0;
+        for row in row_start..row_end {
+            for col in col_start..col_end {
+                let index = row * cols + col;
+                if let Some(value) = raw.get(index) {
+                    sum += *value as f32;
+                    count += 1.0;
+                }
+            }
+        }
+        if count > 0.0 { sum / count } else { 0.0 }
+    };
+
+    let tl = avg(0, sample_rows, 0, sample_cols);
+    let tr = avg(0, sample_rows, cols.saturating_sub(sample_cols), cols);
+    let bl = avg(rows.saturating_sub(sample_rows), rows, 0, sample_cols);
+    let br = avg(
+        rows.saturating_sub(sample_rows),
+        rows,
+        cols.saturating_sub(sample_cols),
+        cols,
+    );
+
+    let left_force = tl + bl;
+    let right_force = tr + br;
+    let top_force = tl + tr;
+    let span = 1200.0_f32.max((PRESSURE_RANGE_MAX - PRESSURE_RANGE_MIN) * 0.22);
+    let raw_axis = ((right_force - left_force) / span).clamp(-1.0, 1.0);
+    let axis = if raw_axis.abs() < 0.045 {
+        0.0
+    } else {
+        raw_axis
+    };
+
+    BreakoutControl {
+        axis,
+        top_force,
+        left_force,
+        right_force,
+    }
+}
+
+fn pressure_pause_threshold() -> f32 {
+    420.0_f32.max(((PRESSURE_RANGE_MAX - PRESSURE_RANGE_MIN).max(1000.0) * 0.07).round())
+}
+
+fn paddle_rect(paddle_x: f32) -> egui::Rect {
+    egui::Rect::from_center_size(
+        egui::pos2(paddle_x, PADDLE_Y),
+        egui::vec2(PADDLE_W, PADDLE_H),
+    )
+}
+
+fn circle_hits_rect(center: egui::Pos2, radius: f32, rect: egui::Rect) -> bool {
+    let closest_x = center.x.clamp(rect.left(), rect.right());
+    let closest_y = center.y.clamp(rect.top(), rect.bottom());
+    let dx = center.x - closest_x;
+    let dy = center.y - closest_y;
+    dx * dx + dy * dy <= radius * radius
+}
+
+fn status_chip(ui: &mut egui::Ui, label: &'static str, value: impl ToString, color: egui::Color32) {
+    egui::Frame::new()
+        .fill(color_alpha(ONE_DARK_PRO.panel_deep, 190))
+        .stroke(egui::Stroke::new(1.0, color_alpha(color, 92)))
+        .corner_radius(egui::CornerRadius::same(4))
+        .inner_margin(egui::Margin::symmetric(8, 4))
+        .show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.colored_label(ONE_DARK_PRO.text_subtle, label);
+                ui.colored_label(color, value.to_string());
+            });
+        });
+}
+
+fn status_color(phase: BreakoutPhase) -> egui::Color32 {
+    match phase {
+        BreakoutPhase::Idle => ONE_DARK_PRO.text_dim,
+        BreakoutPhase::Running => ACCENT_GREEN,
+        BreakoutPhase::Paused => ACCENT_ORANGE,
+        BreakoutPhase::Over => ACCENT_RED,
+    }
+}
+
+fn to_screen(rect: egui::Rect, point: egui::Pos2) -> egui::Pos2 {
+    egui::pos2(
+        rect.left() + point.x * rect.width(),
+        rect.top() + point.y * rect.height(),
+    )
+}
+
+fn to_screen_rect(rect: egui::Rect, local: egui::Rect) -> egui::Rect {
+    egui::Rect::from_min_max(
+        rect.left_top() + local.min.to_vec2() * rect.size(),
+        rect.left_top() + local.max.to_vec2() * rect.size(),
+    )
+}
+
+fn paint_arena_grid(painter: &egui::Painter, rect: egui::Rect) {
+    // 游戏背景保持纯净，避免网格和外框干扰砖块本身的色块节奏。
+    painter.rect_filled(
+        rect,
+        egui::CornerRadius::same(6),
+        egui::Color32::from_rgb(2, 8, 10),
+    );
+
+    painter.rect_stroke(
+        rect,
+        egui::CornerRadius::same(6),
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.accent, 70)),
+        egui::StrokeKind::Inside,
+    );
+}
+
+fn paint_brick(painter: &egui::Painter, arena: egui::Rect, brick: &Brick, index: usize) {
+    let rect = to_screen_rect(arena, brick.rect);
+    if brick.alive {
+        let row = index / BRICK_COLS;
+        let col = index % BRICK_COLS;
+        // 参考示例图：纯色矩形砖块，黑色间隔由砖块之间的空隙自然露出。
+        painter.rect_filled(rect, egui::CornerRadius::ZERO, brick_color(row, col));
+    } else if brick.flash > 0.0 {
+        let alpha = (brick.flash * 150.0) as u8;
+        painter.rect_stroke(
+            rect.expand(4.0 * brick.flash),
+            egui::CornerRadius::same(4),
+            egui::Stroke::new(1.4, color_alpha(ONE_DARK_PRO.accent_hot, alpha)),
+            egui::StrokeKind::Outside,
+        );
+    }
+}
+
+fn paint_paddle(painter: &egui::Painter, arena: egui::Rect, paddle_x: f32) {
+    let rect = to_screen_rect(arena, paddle_rect(paddle_x));
+    // 托盘也改成纯色块，和砖块保持同一种视觉语言。
+    painter.rect_filled(rect, egui::CornerRadius::ZERO, ACCENT_BLUE);
+}
+
+fn paint_ball(painter: &egui::Painter, arena: egui::Rect, ball_pos: egui::Pos2) {
+    let center = to_screen(arena, ball_pos);
+    let radius = BALL_RADIUS * arena.width().min(arena.height());
+    // 球保留为一个普通实心圆，避免额外高光和光晕。
+    painter.circle_filled(center, radius, egui::Color32::from_rgb(241, 207, 70));
+}
+
+fn paint_control_meter(painter: &egui::Painter, arena: egui::Rect, control: BreakoutControl) {
+    let meter_width = arena.width().mul_add(0.30, 0.0).clamp(180.0, 240.0);
+    let meter = egui::Rect::from_min_size(
+        arena.left_bottom() + egui::vec2(18.0, -34.0),
+        egui::vec2(meter_width, 18.0),
+    );
+    painter.rect_filled(
+        meter,
+        egui::CornerRadius::same(4),
+        color_alpha(ONE_DARK_PRO.panel_deep, 220),
+    );
+    painter.rect_stroke(
+        meter,
+        egui::CornerRadius::same(4),
+        egui::Stroke::new(1.0, color_alpha(ONE_DARK_PRO.border, 120)),
+        egui::StrokeKind::Outside,
+    );
+    let center_x = meter.center().x;
+    painter.line_segment(
+        [
+            egui::pos2(center_x, meter.top()),
+            egui::pos2(center_x, meter.bottom()),
+        ],
+        egui::Stroke::new(1.0, ONE_DARK_PRO.border_soft),
+    );
+    let marker_x = center_x + control.axis.clamp(-1.0, 1.0) * meter.width() * 0.45;
+    painter.circle_filled(
+        egui::pos2(marker_x, meter.center().y),
+        5.0,
+        color_alpha(ACCENT_GREEN, 210),
+    );
+    painter.circle_filled(
+        egui::pos2(marker_x, meter.center().y),
+        2.3,
+        color_alpha(egui::Color32::WHITE, 150),
+    );
+    painter.text(
+        meter.right_center() + egui::vec2(10.0, 0.0),
+        egui::Align2::LEFT_CENTER,
+        format!(
+            "L {:>4.0}  R {:>4.0}  T {:>4.0}",
+            control.left_force, control.right_force, control.top_force
+        ),
+        egui::FontId::monospace(10.0),
+        ONE_DARK_PRO.text_dim,
+    );
+}
+
+fn paint_center_overlay(painter: &egui::Painter, rect: egui::Rect, phase: BreakoutPhase) {
+    painter.rect_filled(
+        rect,
+        egui::CornerRadius::same(6),
+        color_alpha(egui::Color32::BLACK, 82),
+    );
+    let (title, detail) = match phase {
+        BreakoutPhase::Idle => ("按压顶部或点击开始", "左右分区压力控制挡板"),
+        BreakoutPhase::Paused => ("已暂停", "再次按压顶部、P 或点击暂停继续"),
+        BreakoutPhase::Over => ("游戏结束", "点击或空格重开"),
+        BreakoutPhase::Running => ("", ""),
+    };
+    painter.text(
+        rect.center() - egui::vec2(0.0, 10.0),
+        egui::Align2::CENTER_CENTER,
+        title,
+        egui::FontId::proportional(24.0),
+        ONE_DARK_PRO.text,
+    );
+    painter.text(
+        rect.center() + egui::vec2(0.0, 20.0),
+        egui::Align2::CENTER_CENTER,
+        detail,
+        egui::FontId::proportional(13.0),
+        ONE_DARK_PRO.text_dim,
+    );
+}
+
+fn brick_color(row: usize, col: usize) -> egui::Color32 {
+    const PALETTE: [egui::Color32; 5] = [
+        egui::Color32::from_rgb(46, 178, 104),
+        egui::Color32::from_rgb(73, 188, 220),
+        egui::Color32::from_rgb(234, 199, 73),
+        egui::Color32::from_rgb(232, 125, 64),
+        egui::Color32::from_rgb(237, 68, 62),
+    ];
+
+    PALETTE[(col + row * 2) % PALETTE.len()]
+}
+
+fn color_alpha(color: egui::Color32, alpha: u8) -> egui::Color32 {
+    egui::Color32::from_rgba_premultiplied(color.r(), color.g(), color.b(), alpha)
+}