diff --git a/Cargo.toml b/Cargo.toml index 7cac5d2..37b676d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ # file: Cargo.toml -# version: 24 +# version: 25 [workspace] resolver = "3" @@ -17,7 +17,7 @@ members = [ ] [workspace.package] -version = "0.1.0-0-pre.11.fix.3" +version = "0.1.0-0-pre.11.fix.4" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/games" diff --git a/crates/engines/engine-v1-sdl/src/runtime.rs b/crates/engines/engine-v1-sdl/src/runtime.rs index 9e0cbec..46f1c83 100644 --- a/crates/engines/engine-v1-sdl/src/runtime.rs +++ b/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, @@ -179,4 +250,4 @@ fn apply_swipe_direction( #[cfg(test)] #[path = "../unit_tests/swipe.rs"] -mod swipe_tests; +mod tests; diff --git a/crates/engines/engine-v1-sdl/unit_tests/swipe.rs b/crates/engines/engine-v1-sdl/unit_tests/swipe.rs index fca972e..ad21463 100644 --- a/crates/engines/engine-v1-sdl/unit_tests/swipe.rs +++ b/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))); +} diff --git a/deltas/0.1.0/0-pre.11.fix.4.md b/deltas/0.1.0/0-pre.11.fix.4.md new file mode 100644 index 0000000..224b08c --- /dev/null +++ b/deltas/0.1.0/0-pre.11.fix.4.md @@ -0,0 +1,155 @@ + + + +# Delta 0.1.0-0-pre.11.fix.4 + +## Base + +Base déclarée : `0.1.0-0-pre.11.fix.3`, non validée. + +## Motifs + +Deux points restent à corriger avant validation finale de `0-pre.*`. + +### Audit RUST-TEST-001 + +Le module externe `unit_tests/swipe.rs` était déclaré avec : + +```text +mod swipe_tests; +``` + +alors que la règle workspace exige la forme canonique : + +```text +mod tests; +``` + +Le corps des tests reste bien hors de `src/`. + +### Sortie explicite + +Le smoke Android a montré un gameplay fonctionnel et des swipes nettement meilleurs, mais aucun contrôle visuel de sortie n'était disponible dans le jeu plein écran. + +## Sortie Desktop + +`Escape` continue de quitter directement la boucle SDL, sans nécessiter le bouton de fermeture de la fenêtre. + +## Sortie Android + +Le backend SDL configure : + +```text +SDL_ANDROID_TRAP_BACK_BUTTON=1 +``` + +et quitte la boucle sur `Keycode::AcBack`. + +Un contrôle de fermeture rouge avec un X blanc est également rendu en haut à droite. + +Zone normalisée : + +```text +x = 0.86 .. 0.99 +y = 0.015 .. 0.105 +``` + +Un `MouseButtonDown` ou `FingerDown` dans cette zone quitte la boucle avant toute transmission de l'input au jeu. + +Aucun `exit()` n'est utilisé : `SdlRuntime::run` retourne normalement, puis l'entrypoint Android retourne à SDL/Java. + +## Tests + +Le fichier externe `unit_tests/swipe.rs` vérifie désormais aussi le hit-test du contrôle de sortie. + +## Validation Rust + +```bash +cargo fmt --all +cargo fmt --all -- --check + +python3 scripts/audit_rust_workspace_rules.py +python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates Android deltas history + +cargo check --workspace +cargo clippy --workspace --all-targets --all-features -- -D warnings + +cargo test -p engine-v1-sdl --all-targets --all-features +cargo test -p game-snake-poc --all-targets --all-features +``` + +## Smoke Desktop + +```bash +cargo run -p game-snake-poc-desktop +``` + +Critères supplémentaires : + +- `Escape` quitte sans cliquer sur le bouton de fenêtre ; +- aucun contrôle Android n'est visible sur Desktop. + +## Smoke Android x86_64 + +```bash +python3 scripts/build_android_rust.py snake --abi x86_64 + +cd Android +gradle :game-snake-poc:assembleDebug +cd .. +``` + +Puis : + +```bash +android emulator start sasedev_games_api36 +adb devices + +android run \ + --apks=Android/game-snake-poc/build/outputs/apk/debug/game-snake-poc-debug.apk \ + --device=emulator-5554 +``` + +Critères supplémentaires : + +- contrôle de fermeture visible en haut à droite ; +- tap dessus termine proprement l'Activity ; +- Back système termine également proprement l'Activity ; +- aucun input Snake n'est déclenché par le contrôle de fermeture. + +## Test physique Galaxy S9+ + +Activer les Options développeur et le Débogage USB, connecter le téléphone et accepter l'autorisation RSA. + +Identifier son serial et son ABI : + +```bash +adb devices +adb -s shell getprop ro.product.cpu.abi +``` + +Reconstruire ARM64 après ce fix : + +```bash +python3 scripts/build_android_rust.py snake --abi arm64-v8a + +cd Android +gradle :game-snake-poc:assembleDebug +cd .. +``` + +Déployer : + +```bash +android run \ + --apks=Android/game-snake-poc/build/outputs/apk/debug/game-snake-poc-debug.apk \ + --device= +``` + +Le téléphone réel sert à juger la latence et la qualité tactile, pas seulement la compatibilité d'installation. + +## Transition + +Si les gates et les smokes sont propres, `0.1.0-0-pre.11.fix.4` valide la fin de la phase `0-pre.*`. + +En cas d'échec imputable au projet, produire `0.1.0-0-pre.11.fix.5`. diff --git a/docs/architecture/004-INPUT_AND_CONTROLS.md b/docs/architecture/004-INPUT_AND_CONTROLS.md index 7d31508..438cb58 100644 --- a/docs/architecture/004-INPUT_AND_CONTROLS.md +++ b/docs/architecture/004-INPUT_AND_CONTROLS.md @@ -1,5 +1,5 @@ - + # Abstraction des entrées et contrôles @@ -96,3 +96,19 @@ Pour souris et tactile : - `Canceled` annule le geste. Reflex conserve son impulsion `Primary` sur `Down` et reste donc indépendant de la reconnaissance du swipe. + +## Sortie utilisateur + +Desktop : + +- `Escape` quitte proprement la boucle SDL ; +- la fermeture de fenêtre continue d'émettre `Quit`. + +Android : + +- `SDL_ANDROID_TRAP_BACK_BUTTON=1` permet de traiter `AcBack` comme sortie propre ; +- un contrôle visuel de fermeture est rendu en haut à droite ; +- un tap/clic dans cette zone quitte la boucle avant d'alimenter le gameplay ; +- la boucle retourne ensuite normalement vers `SDL_main`. + +Le gameplay ne dépend pas de cette logique de cycle de vie.