0.1.0-0-pre.11-fix.4

crates/engines/engine-v1-sdl/src/runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/engines/engine-v1-sdl/src/runtime.rs
-// version: 9
+// version: 10
 
 /// Minimal SDL3 runtime used by Desktop and Android POC runners.
 pub struct SdlRuntime {
@@ -21,6 +21,10 @@ impl SdlRuntime {
     where
         G: engine_v1_common::EngineGame,
     {
+        #[cfg(target_os = "android")]
+        {
+            let _ = sdl3::hint::set(sdl3::hint::names::ANDROID_TRAP_BACK_BUTTON, "1");
+        }
         let sdl = match sdl3::init() {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
@@ -48,6 +52,7 @@ impl SdlRuntime {
                 match event {
                     sdl3::event::Event::Quit { .. } => break 'running,
                     sdl3::event::Event::KeyDown { keycode: Some(sdl3::keyboard::Keycode::Escape), .. } => break 'running,
+                    sdl3::event::Event::KeyDown { keycode: Some(sdl3::keyboard::Keycode::AcBack), .. } => break 'running,
                     sdl3::event::Event::KeyDown { keycode: Some(sdl3::keyboard::Keycode::Left), repeat: false, .. } => {
                         input = input.with_action(engine_v1_common::GameAction::Left, true);
                     },
@@ -62,6 +67,9 @@ impl SdlRuntime {
                     },
                     sdl3::event::Event::MouseButtonDown { mouse_btn: sdl3::mouse::MouseButton::Left, x, y, .. } => {
                         pointer = normalize_mouse_pointer(&canvas, true, x, y);
+                        if platform_quit_control_hit(pointer) {
+                            break 'running;
+                        }
                         gesture_start = Some(pointer);
                         input = input.with_pointer(pointer).with_action(engine_v1_common::GameAction::Primary, true);
                     },
@@ -78,6 +86,9 @@ impl SdlRuntime {
                     },
                     sdl3::event::Event::FingerDown { x, y, .. } => {
                         pointer = engine_v1_common::PointerState::normalized(true, x, y);
+                        if platform_quit_control_hit(pointer) {
+                            break 'running;
+                        }
                         gesture_start = Some(pointer);
                         input = input.with_pointer(pointer).with_action(engine_v1_common::GameAction::Primary, true);
                     },
@@ -142,12 +153,72 @@ fn render_scene(canvas: &mut sdl3::render::WindowCanvas, scene: engine_v1_common
             std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
         }
     }
+    match render_platform_controls(canvas, width, height) {
+        std::result::Result::Ok(()) => {},
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    }
     canvas.present();
     return std::result::Result::Ok(());
 }
 
 const SWIPE_DIRECTION_THRESHOLD: f32 = 0.04;
 
+fn platform_quit_control_hit(pointer: engine_v1_common::PointerState) -> bool {
+    #[cfg(target_os = "android")]
+    {
+        return quit_control_hit(pointer);
+    }
+    #[cfg(not(target_os = "android"))]
+    {
+        let _ = pointer;
+        return false;
+    }
+}
+
+fn quit_control_hit(pointer: engine_v1_common::PointerState) -> bool {
+    return pointer.x() >= 0.86 && pointer.x() <= 0.99 && pointer.y() >= 0.015 && pointer.y() <= 0.105;
+}
+
+fn render_platform_controls(canvas: &mut sdl3::render::WindowCanvas, width: u32, height: u32) -> std::result::Result<(), std::string::String> {
+    #[cfg(target_os = "android")]
+    {
+        let button = sdl3::render::FRect::new(0.86 * width as f32, 0.015 * height as f32, 0.13 * width as f32, 0.09 * height as f32);
+        canvas.set_draw_color(sdl3::pixels::Color::RGBA(176, 48, 48, 232));
+        match canvas.fill_rect(button) {
+            std::result::Result::Ok(()) => {},
+            std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+        }
+
+        canvas.set_draw_color(sdl3::pixels::Color::RGBA(255, 255, 255, 255));
+        let marks = [
+            (0.885_f32, 0.032_f32),
+            (0.905_f32, 0.044_f32),
+            (0.925_f32, 0.056_f32),
+            (0.945_f32, 0.068_f32),
+            (0.965_f32, 0.080_f32),
+            (0.965_f32, 0.032_f32),
+            (0.945_f32, 0.044_f32),
+            (0.925_f32, 0.056_f32),
+            (0.905_f32, 0.068_f32),
+            (0.885_f32, 0.080_f32),
+        ];
+        for (x, y) in marks {
+            let mark = sdl3::render::FRect::new(x * width as f32, y * height as f32, 0.012 * width as f32, 0.012 * height as f32);
+            match canvas.fill_rect(mark) {
+                std::result::Result::Ok(()) => {},
+                std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+            }
+        }
+    }
+    #[cfg(not(target_os = "android"))]
+    {
+        let _ = canvas;
+        let _ = width;
+        let _ = height;
+    }
+    return std::result::Result::Ok(());
+}
+
 fn apply_swipe_direction(
     mut input: engine_v1_common::InputState,
     start: Option<engine_v1_common::PointerState>,
@@ -179,4 +250,4 @@ fn apply_swipe_direction(
 
 #[cfg(test)]
 #[path = "../unit_tests/swipe.rs"]
-mod swipe_tests;
+mod tests;

crates/engines/engine-v1-sdl/unit_tests/swipe.rs

@@ -1,5 +1,5 @@
 // file: crates/engines/engine-v1-sdl/unit_tests/swipe.rs
-// version: 1
+// version: 2
 
 fn pointer(x: f32, y: f32) -> engine_v1_common::PointerState {
     return engine_v1_common::PointerState::normalized(true, x, y);
@@ -25,3 +25,10 @@ fn vertical_swipe_uses_dominant_axis() {
     let input = super::apply_swipe_direction(engine_v1_common::InputState::none(), Some(pointer(0.5, 0.8)), pointer(0.55, 0.2));
     assert!(input.is_active(engine_v1_common::GameAction::Up));
 }
+
+#[test]
+fn quit_control_hit_is_limited_to_top_right_region() {
+    assert!(super::quit_control_hit(pointer(0.92, 0.05)));
+    assert!(!super::quit_control_hit(pointer(0.50, 0.05)));
+    assert!(!super::quit_control_hit(pointer(0.92, 0.50)));
+}