From e07facacd875416cbf01890fcfe88bdbbbf97f47 Mon Sep 17 00:00:00 2001
From: Cyrus <86699936+cyrusae@users.noreply.github.com>
Date: Thu, 28 May 2026 21:56:39 -0700
Subject: [PATCH] feat: touchscreen support

---
 index.html       |  2 ++
 src/core_math.rs |  2 +-
 src/launcher.rs  | 70 ++++++++++++++++++++++++++++++++----------------
 src/main.rs      | 30 ++++++++++++++++++++-
 src/physics.rs   | 19 ++++++-------
 5 files changed, 89 insertions(+), 34 deletions(-)

diff --git a/index.html b/index.html
index b0ecfe2..a41358f 100644
--- a/index.html
+++ b/index.html
@@ -3,6 +3,7 @@
 <head>
     <meta charset="utf-8">
     <title>akiuS</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
     <link data-trunk rel="rust" />
     <style>
         body {
@@ -19,6 +20,7 @@
             display: block;
             width: 100%;
             height: 100%;
+            touch-action: none;
         }
         canvas:focus {
             outline: none;
diff --git a/src/core_math.rs b/src/core_math.rs
index 8fe74e3..7b4cf93 100644
--- a/src/core_math.rs
+++ b/src/core_math.rs
@@ -73,7 +73,7 @@ mod tests {
         for _ in 0..iterations {
             let tier = get_random_dispensed_tier(&mut rng);
             assert!(
-                tier >= 1 && tier <= 4,
+                (1..=4).contains(&tier),
                 "Dispensed tier out of bounds: {}",
                 tier
             );
diff --git a/src/launcher.rs b/src/launcher.rs
index 8159a4a..abfaf80 100644
--- a/src/launcher.rs
+++ b/src/launcher.rs
@@ -62,6 +62,7 @@ pub fn update_launcher_aiming(
     >,
     mut launcher_state: ResMut<LauncherState>,
     keyboard: Res<ButtonInput<KeyCode>>,
+    touches: Res<Touches>,
     time: Res<Time>,
 ) {
     let half_width = settings.arena_width * 0.5;
@@ -69,30 +70,38 @@ pub fn update_launcher_aiming(
     let preview_radius = crate::core_math::get_radius(current_tier);
     let limit_x = (half_width - preview_radius).max(0.0);
 
-    // 1. Get cursor position and check if it moved
+    // 1. Get position from touch or cursor
     let mut new_target_x = None;
-    let mut current_cursor_position = None;
-
-    if let Ok(window) = window_query.single() {
-        if let Some(cursor_pos) = window.cursor_position() {
-            current_cursor_position = Some(cursor_pos);
-            if let Ok((camera, camera_transform)) = camera_query.single() {
-                if let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_pos) {
-                    let dir_y = ray.direction.y;
-                    if dir_y.abs() >= 1e-6 {
-                        let t = -ray.origin.y / dir_y;
-                        if t >= 0.0 {
-                            let intersection_point = ray.origin + t * *ray.direction;
-                            new_target_x = Some(intersection_point.x.clamp(-limit_x, limit_x));
-                        }
+    let mut current_input_position = None;
+    let mut is_touch = false;
+
+    if let Some(touch_pos) = touches.first_pressed_position() {
+        current_input_position = Some(touch_pos);
+        is_touch = true;
+    } else if let Ok(window) = window_query.single() {
+        current_input_position = window.cursor_position();
+    }
+
+    if let Some(input_pos) = current_input_position {
+        if let Ok((camera, camera_transform)) = camera_query.single() {
+            if let Ok(ray) = camera.viewport_to_world(camera_transform, input_pos) {
+                let dir_y = ray.direction.y;
+                if dir_y.abs() >= 1e-6 {
+                    let t = -ray.origin.y / dir_y;
+                    if t >= 0.0 {
+                        let intersection_point = ray.origin + t * *ray.direction;
+                        new_target_x = Some(intersection_point.x.clamp(-limit_x, limit_x));
                     }
                 }
             }
         }
     }
 
-    let cursor_moved = if let Some(pos) = current_cursor_position {
-        if let Some(last_pos) = launcher_state.last_cursor_position {
+    let input_moved = if let Some(pos) = current_input_position {
+        if is_touch {
+            // Touch targeting directly controls launcher positioning
+            true
+        } else if let Some(last_pos) = launcher_state.last_cursor_position {
             (pos - last_pos).length_squared() > 1e-4
         } else {
             true
@@ -101,9 +110,9 @@ pub fn update_launcher_aiming(
         false
     };
 
-    // 2. Decide target_x source (cursor vs keyboard)
+    // 2. Decide target_x source (input vs keyboard)
     let mut clamped_x = launcher_state.target_x;
-    if cursor_moved {
+    if input_moved {
         if let Some(x) = new_target_x {
             clamped_x = x;
         }
@@ -124,8 +133,12 @@ pub fn update_launcher_aiming(
         }
     }
 
-    // Always update last cursor position
-    launcher_state.last_cursor_position = current_cursor_position;
+    // Always update last input position if not touch
+    if !is_touch {
+        launcher_state.last_cursor_position = current_input_position;
+    } else {
+        launcher_state.last_cursor_position = None;
+    }
 
     // Compute 1D forbidden intervals on the launcher line (Z = settings.launcher_z)
     let mut intervals: Vec<(f32, f32)> = Vec::new();
@@ -236,6 +249,7 @@ pub fn handle_launch_input(
     mut commands: Commands,
     mouse_button_input: Res<ButtonInput<MouseButton>>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
+    touches: Res<Touches>,
     settings: Res<GameSettings>,
     dispenser_queue: Option<ResMut<crate::game_state::DispenserQueue>>,
     mut launcher_state: ResMut<LauncherState>,
@@ -246,8 +260,14 @@ pub fn handle_launch_input(
     launcher_state.cooldown_timer.tick(time.delta());
 
     let over_ui = interaction_query.iter().any(|&i| i != Interaction::None);
-    let fire_pressed = (mouse_button_input.just_pressed(MouseButton::Left) && !over_ui)
-        || keyboard_input.just_pressed(KeyCode::Space);
+    let is_touch_active = touches.iter().next().is_some() || touches.any_just_released();
+
+    let fire_pressed = if is_touch_active {
+        touches.any_just_released() && !over_ui
+    } else {
+        (mouse_button_input.just_pressed(MouseButton::Left) && !over_ui)
+            || keyboard_input.just_pressed(KeyCode::Space)
+    };
 
     let merge_active = !merge_cooldowns.is_empty();
 
@@ -309,6 +329,7 @@ mod tests {
         app.insert_resource(GameSettings::default());
         app.insert_resource(LauncherState::default());
         app.insert_resource(ButtonInput::<KeyCode>::default());
+        app.insert_resource(Touches::default());
         app.insert_resource(Time::<()>::default());
 
         let camera_transform = Transform::from_xyz(0.0, 10.0, 0.0).looking_at(Vec3::ZERO, -Vec3::Z);
@@ -393,6 +414,7 @@ mod tests {
         });
         app.insert_resource(ButtonInput::<MouseButton>::default());
         app.insert_resource(ButtonInput::<KeyCode>::default());
+        app.insert_resource(Touches::default());
         app.insert_resource(Time::<()>::default());
         app.add_systems(Update, handle_launch_input);
 
@@ -439,6 +461,7 @@ mod tests {
         });
         app.insert_resource(ButtonInput::<MouseButton>::default());
         app.insert_resource(ButtonInput::<KeyCode>::default());
+        app.insert_resource(Touches::default());
         app.insert_resource(Time::<()>::default());
         app.add_systems(Update, handle_launch_input);
 
@@ -487,6 +510,7 @@ mod tests {
         });
         app.insert_resource(ButtonInput::<MouseButton>::default());
         app.insert_resource(ButtonInput::<KeyCode>::default());
+        app.insert_resource(Touches::default());
         app.insert_resource(Time::<()>::default());
         app.add_systems(Update, handle_launch_input);
 
diff --git a/src/main.rs b/src/main.rs
index 3336dcf..9150074 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::type_complexity, clippy::too_many_arguments)]
+
 mod core_math;
 mod game_state;
 mod hud;
@@ -53,10 +55,36 @@ fn main() {
             )
                 .run_if(in_state(game_state::AppState::InGame)),
         )
-        .add_systems(Update, game_state::update_high_score)
+        .add_systems(Update, (game_state::update_high_score, adjust_camera_fov))
         .run();
 }
 
+/// Dynamically adjusts the camera's vertical FOV on narrow screens to prevent horizontal clipping of the board.
+fn adjust_camera_fov(
+    window_query: Query<&Window>,
+    mut camera_query: Query<&mut Projection, With<Camera3d>>,
+) {
+    let Ok(window) = window_query.single() else {
+        return;
+    };
+    let Ok(mut projection) = camera_query.single_mut() else {
+        return;
+    };
+
+    if let Projection::Perspective(ref mut perspective) = *projection {
+        let aspect_ratio = window.width() / window.height();
+        if aspect_ratio < 1.0 {
+            // Keep the horizontal field of view constant by adjusting vertical fov:
+            // tan(fov_v / 2) = tan(fov_h_desired / 2) / aspect_ratio
+            // Target a horizontal FOV half-angle tangent of 0.5317.
+            let desired_fov_v = 2.0 * (0.5317 / aspect_ratio).atan();
+            perspective.fov = desired_fov_v.clamp(std::f32::consts::FRAC_PI_4, 1.6);
+        } else {
+            perspective.fov = std::f32::consts::FRAC_PI_4;
+        }
+    }
+}
+
 /// Camera and lighting only — scene geometry is handled by VisualPlugin.
 fn setup_camera_and_light(mut commands: Commands) {
     // 3D perspective camera for the game scene.
diff --git a/src/physics.rs b/src/physics.rs
index fb705f1..c47bfbf 100644
--- a/src/physics.rs
+++ b/src/physics.rs
@@ -140,15 +140,16 @@ pub fn check_distance_merges(
                 let threshold = r1 + r2 + 0.07;
                 let dist = t1.translation.distance(t2.translation);
 
-                if dist < threshold {
-                    if !merged_this_frame.contains(&e1) && !merged_this_frame.contains(&e2) {
-                        merged_this_frame.insert(e1);
-                        merged_this_frame.insert(e2);
-                        merge_events.write(MergeEvent {
-                            entity_a: e1,
-                            entity_b: e2,
-                        });
-                    }
+                if dist < threshold
+                    && !merged_this_frame.contains(&e1)
+                    && !merged_this_frame.contains(&e2)
+                {
+                    merged_this_frame.insert(e1);
+                    merged_this_frame.insert(e2);
+                    merge_events.write(MergeEvent {
+                        entity_a: e1,
+                        entity_b: e2,
+                    });
                 }
             }
         }
-- 
2.51.2