outfly/src/camera.rs

use bevy::prelude::*;
use bevy::input::mouse::MouseMotion;
use bevy::window::PrimaryWindow;
use std::f32::consts::*;
use crate::{settings, audio, actor};

pub struct CameraControllerPlugin;

impl Plugin for CameraControllerPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Update, run_camera_controller);
    }
}

// Based on Valorant's default sensitivity, not entirely sure why it is exactly 1.0 / 180.0,
// but I'm guessing it is a misunderstanding between degrees/radians and then sticking with
// it because it felt nice.
pub const RADIANS_PER_DOT: f32 = 1.0 / 180.0;

#[derive(Component)]
pub struct CameraController {
    pub enabled: bool,
    pub initialized: bool,
    pub sensitivity: f32,
    pub pitch: f32,
    pub yaw: f32,
}

impl Default for CameraController {
    fn default() -> Self {
        Self {
            enabled: true,
            initialized: false,
            sensitivity: 0.5,
            pitch: 1.0, // pitch=0/yaw=0 -> face sun
            yaw: 0.3,
        }
    }
}

#[allow(clippy::too_many_arguments)]
fn run_camera_controller(
    time: Res<Time>,
    settings: Res<settings::Settings>,
    mut windows: Query<&mut Window, With<PrimaryWindow>>,
    mut mouse_events: EventReader<MouseMotion>,
    key_input: Res<ButtonInput<KeyCode>>,
    thruster_sound_controller: Query<&AudioSink, With<audio::ComponentThrusterSound>>,
    rocket_sound_controller: Query<&AudioSink, With<audio::ComponentRocketSound>>,
    mut q_engine: Query<&mut actor::Engine, With<actor::PlayerDrivesThis>>,
    mut query: Query<(
            &mut Transform,
            &mut CameraController,
            &mut Projection,
            &mut actor::Actor,
            &actor::LifeForm,
            &mut actor::Engine
        ), (With<Camera>, Without<actor::PlayerDrivesThis>)>,
) {
    let dt = time.delta_seconds();
    let mut play_thruster_sound = false;

    let window_result = windows.get_single_mut();
    let mut focused = true;
    if window_result.is_ok() {
        focused = window_result.unwrap().focused;
    }

    if let Ok((mut transform, mut controller, mut projection, mut actor, lifeform, player_engine)) = query.get_single_mut() {
        if !controller.initialized {
            controller.initialized = true;
            transform.rotation =
                Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
        }
        if !controller.enabled {
            mouse_events.clear();
            return;
        }

        // Handle key input
        let mut axis_input = Vec3::ZERO;
        if focused {
            if key_input.pressed(settings.key_forward) {
                axis_input.z -= 1.0;
            }
            if key_input.pressed(settings.key_back) {
                axis_input.z += 1.0;
            }
            if key_input.pressed(settings.key_right) {
                axis_input.x += 1.0;
            }
            if key_input.pressed(settings.key_left) {
                axis_input.x -= 1.0;
            }
            if key_input.pressed(settings.key_up) {
                axis_input.y += 1.0;
            }
            if key_input.pressed(settings.key_down) {
                axis_input.y -= 1.0;
            }
        }

        if key_input.pressed(settings.key_stop) {
            if actor.v.length_squared() < 1e-6 {
                actor.v = Vec3::ZERO;
            }
        }

        let mut engine = if let Ok(engine) = q_engine.get_single_mut() { engine } else { player_engine };

        // Apply movement update
        let mut acceleration_camera: Vec3;
        if axis_input != Vec3::ZERO {
            acceleration_camera = axis_input;
        } else {
            acceleration_camera = Vec3::ZERO;
        }

        if key_input.pressed(settings.key_stop) {
            let stop_direction = -actor.v.normalize();
            if stop_direction.length_squared() > 0.3 {
                acceleration_camera += transform.rotation.inverse() * stop_direction;
            }
        }

        let forward_factor =  engine.current_warmup * (if acceleration_camera.z < 0.0 {
            engine.thrust_forward
        } else {
            engine.thrust_back
        });
        let right_factor = engine.thrust_sideways * engine.current_warmup;
        let up_factor = engine.thrust_sideways * engine.current_warmup;
        let factor = Vec3::new(right_factor, up_factor, forward_factor);

        if acceleration_camera.length_squared() > 0.3 {
            let acceleration_global = transform.rotation * (acceleration_camera.normalize() * factor);
            dbg!(acceleration_camera);
            dbg!(acceleration_global);

            let speed_multiplier = 30.0;
            actor.v += speed_multiplier * dt * acceleration_global;

            engine.current_warmup = (engine.current_warmup + dt / engine.warmup_seconds).clamp(0.0, 1.0);
            play_thruster_sound = !settings.mute_sfx;
        }
        else {
            engine.current_warmup = (engine.current_warmup - dt / engine.warmup_seconds).clamp(0.0, 1.0);
        }

        // Handle mouse input
        let mut mouse_delta = Vec2::ZERO;
        for mouse_event in mouse_events.read() {
            mouse_delta += mouse_event.delta;
        }

        if mouse_delta != Vec2::ZERO {
            // Apply look update
            controller.pitch = (controller.pitch
                - mouse_delta.y * RADIANS_PER_DOT * controller.sensitivity)
                .clamp(-PI / 2., PI / 2.);
            controller.yaw -= mouse_delta.x * RADIANS_PER_DOT * controller.sensitivity;
            transform.rotation =
                Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
        }

        let fov = (lifeform.adrenaline * lifeform.adrenaline * lifeform.adrenaline * 45.0 + 45.0).to_radians();
        *projection = Projection::Perspective(PerspectiveProjection { fov: fov, ..default() });

        if let Ok(sink) = thruster_sound_controller.get_single() {
            if play_thruster_sound && engine.engine_type == actor::EngineType::Monopropellant {
                sink.play()
            } else {
                sink.pause()
            }
        }
        if let Ok(sink) = rocket_sound_controller.get_single() {
            if play_thruster_sound && engine.engine_type == actor::EngineType::Rocket {
                sink.play()
            } else {
                sink.pause()
            }
        }
    }
}