bevy-ichun 0.5.0

//! # Input Handling for Character Controller
//!
//! This module provides systems and components for translating player input into
//! character movement events. It supports keyboard and mouse input.
//!
//! The input systems detect player input and generate events that the movement
//! systems respond to. This separation allows for flexible input configuration
//! without modifying the movement logic.
//!
//! ## Features
//!
//! * Customizable key bindings for all actions
//! * Support for multiple keys per action
//! * Toggleable running and floating modes
//! * Optional activation keys for rotation (e.g. right mouse button)
//! * Global and per-character input handling activation
//!
//! ## Components
//!
//! * [`KccInputConfig`]: Configures input bindings and behavior
//!
//! ## Systems
//!
//! * `movement_input_sys`: Handles horizontal movement key input for movement
//! * `run_input_sys`: Handles run key input (toggle or hold)
//! * `jump_input_sys`: Handles jump key input
//! * `float_input_sys`: Handles float / glide key input (toggle or hold)
//! * `rotation_input_sys`: Handles mouse input for camera rotation
use avian3d::math::{Scalar, Vector2};
use bevy::{
    app::{Plugin, Update},
    ecs::{
        component::Component,
        entity::Entity,
        event::EventWriter,
        query::With,
        resource::Resource,
        schedule::IntoScheduleConfigs,
        system::{Query, Res},
    },
    input::{ButtonInput, keyboard::KeyCode, mouse::AccumulatedMouseMotion},
    platform::collections::HashSet,
};

use crate::{
    kcc::Kcc,
    movement_events::{
        IchunFloatEvent, IchunJumpEvent, IchunMoveEvent, IchunRotateEvent, IchunRunEvent,
        KccMovementEventsConfig,
    },
    system_sets::IchunSystemSet,
};

/// Component to configure the input to move the KCC
///
/// This component defines the key bindings and input behavior for controlling
/// a character. It must be attached to an entity that also has the [`Kcc`] and
/// [`KccMovementConfig`] components.
///
/// It allows customizing keys for movement, running, jumping, floating, and
/// camera rotation, as well as setting toggle/hold behavior for actions.
///
/// # Example
///
/// ```rust
/// use bevy_ichun::input::{KccInputConfig, RunConditions};
/// use bevy::input::keyboard::KeyCode;
///
/// // Create a custom input configuration with WASD movement,
/// // Space to jump, and Left Shift to run
/// let input_config = KccInputConfig::new(
///     // Forward keys
///     [KeyCode::KeyW],
///     // Backward keys
///     [KeyCode::KeyS],
///     // Left keys
///     [KeyCode::KeyA],
///     // Right keys
///     [KeyCode::KeyD],
///     // Run conditions
///     RunConditions { forward_only: true },
///     // Run is toggled
///     true,
///     // Run keys
///     [KeyCode::ShiftLeft],
///     // Jump keys
///     [KeyCode::Space],
///     // Float is held
///     false,
///     // Float keys
///     [KeyCode::Space],
///     // Rotation activation (none = always active)
///     None::<[KeyCode; 0]>,
///     // Input handling active
///     true,
/// );
/// ```
#[derive(Component)]
#[require(Kcc, KccMovementEventsConfig)]
pub struct KccInputConfig {
    /// Keys that trigger forward movement
    pub forward: HashSet<KeyCode>,
    /// Keys that trigger backward movement
    pub backward: HashSet<KeyCode>,
    /// Keys that trigger leftward movement
    pub left: HashSet<KeyCode>,
    /// Keys that trigger rightward movement
    pub right: HashSet<KeyCode>,
    /// Conditions that must be met for running to be allowed
    pub run_conditions: RunConditions,
    /// Determines the running mode:
    /// - If `true`: Running is toggled on/off with a key press
    /// - If `false`: Running is active only while the run key is held down
    pub is_running_toggled: bool,
    /// Keys that trigger running
    pub run: HashSet<KeyCode>,
    /// Keys that trigger jumping
    pub jump: HashSet<KeyCode>,
    /// Determines the floating mode:
    /// - If `true`: Floating is toggled on/off with a key press
    /// - If `false`: Floating is active only while the float key is held down
    pub is_floating_toggled: bool,
    /// Keys that trigger floating/gliding
    pub float: HashSet<KeyCode>,
    /// Button which needs to be pressed to activate rotation input (e.g., right click in MMORPGs)
    /// None if no button needs to be pressed to activate rotation
    pub rotation_activation: Option<HashSet<KeyCode>>,
    /// Field which decides if input for this KCC is handled or not
    pub input_handling_active: bool,
}

/// The default input is:
/// Movement with W, A, S, D,
/// Running can be toggled with left Shift
/// Jumping with Space
/// Floating with holding down Space
impl Default for KccInputConfig {
    fn default() -> Self {
        let mut forward = HashSet::new();
        forward.insert(KeyCode::KeyW);

        let mut backward = HashSet::new();
        backward.insert(KeyCode::KeyS);

        let mut left = HashSet::new();
        left.insert(KeyCode::KeyA);

        let mut right = HashSet::new();
        right.insert(KeyCode::KeyD);

        let mut run = HashSet::new();
        run.insert(KeyCode::ShiftLeft);

        let mut jump = HashSet::new();
        jump.insert(KeyCode::Space);

        let mut float = HashSet::new();
        float.insert(KeyCode::Space);

        Self {
            forward,
            backward,
            left,
            right,
            run_conditions: RunConditions { forward_only: true },
            is_running_toggled: true,
            run,
            jump,
            is_floating_toggled: false,
            float,
            rotation_activation: None,
            input_handling_active: true,
        }
    }
}

impl KccInputConfig {
    pub fn new(
        forward: impl IntoIterator<Item = KeyCode>,
        backward: impl IntoIterator<Item = KeyCode>,
        left: impl IntoIterator<Item = KeyCode>,
        right: impl IntoIterator<Item = KeyCode>,
        run_conditions: RunConditions,
        is_running_toggled: bool,
        run: impl IntoIterator<Item = KeyCode>,
        jump: impl IntoIterator<Item = KeyCode>,
        is_floating_toggled: bool,
        float: impl IntoIterator<Item = KeyCode>,
        rotation_activation: Option<impl IntoIterator<Item = KeyCode>>,
        input_handling_active: bool,
    ) -> Self {
        Self {
            forward: forward.into_iter().collect(),
            backward: backward.into_iter().collect(),
            left: left.into_iter().collect(),
            right: right.into_iter().collect(),
            run_conditions,
            is_running_toggled,
            run: run.into_iter().collect(),
            jump: jump.into_iter().collect(),
            is_floating_toggled,
            float: float.into_iter().collect(),
            rotation_activation: rotation_activation.map(|keys| keys.into_iter().collect()),
            input_handling_active,
        }
    }
}

/// Conditions to check if running is possible
///
/// This struct defines conditions that must be met for a character
/// to be allowed to enter the running state.
///
/// # Fields
///
/// * `forward_only`: If true, running is only allowed when moving forward
#[derive(Default)]
pub struct RunConditions {
    /// If true, running is only allowed when moving forward
    pub forward_only: bool,
}

/// Resource which can (de)activate input handling for all KCC
#[derive(Resource)]
struct InputHandling {
    input_handling_active: bool,
}

pub struct IchunInputPlugin;

impl Plugin for IchunInputPlugin {
    fn build(&self, app: &mut bevy::app::App) {
        app.insert_resource(InputHandling {
            input_handling_active: true, // Default to active
        })
        .add_systems(
            Update,
            (
                rotation_input_sys,
                jump_input_sys,
                run_input_sys,
                movement_input_sys,
                float_input_sys,
            )
                .chain()
                .in_set(IchunSystemSet::InputSet),
        );
    }
}

fn movement_input_sys(
    mut movement_event_writer: EventWriter<IchunMoveEvent>,
    keyboard_input_res: Res<ButtonInput<KeyCode>>,
    input_handling_res: Res<InputHandling>,
    kcc_qry: Query<(Entity, &KccInputConfig), With<Kcc>>,
) {
    if !input_handling_res.input_handling_active {
        return;
    }

    for (entity, input) in kcc_qry.iter() {
        if !input.input_handling_active {
            continue;
        }

        let right_pressed = input
            .right
            .iter()
            .any(|&key| keyboard_input_res.pressed(key));
        let left_pressed = input
            .left
            .iter()
            .any(|&key| keyboard_input_res.pressed(key));
        let forward_pressed = input
            .forward
            .iter()
            .any(|&key| keyboard_input_res.pressed(key));
        let backward_pressed = input
            .backward
            .iter()
            .any(|&key| keyboard_input_res.pressed(key));

        let horizontal = right_pressed as i8 - left_pressed as i8;
        let vertical = forward_pressed as i8 - backward_pressed as i8;

        let direction =
            Vector2::new(horizontal as Scalar, -vertical as Scalar).clamp_length_max(1.0);

        if direction != Vector2::ZERO {
            movement_event_writer.write(IchunMoveEvent { entity, direction });
        }
    }
}

fn run_input_sys(
    mut run_event_writer: EventWriter<IchunRunEvent>,
    keyboard_input_res: Res<ButtonInput<KeyCode>>,
    input_handling_res: Res<InputHandling>,
    kcc_qry: Query<(Entity, &KccInputConfig, &KccMovementEventsConfig), With<Kcc>>,
) {
    if !input_handling_res.input_handling_active {
        return;
    }

    for (entity, input, movement) in kcc_qry.iter() {
        if !input.input_handling_active {
            continue;
        }

        // Check if running is allowed based on conditions
        let run_conditions_met = !input.run_conditions.forward_only
            || input
                .forward
                .iter()
                .any(|&key| keyboard_input_res.pressed(key));

        // If conditions not met and currently running, stop running
        if !run_conditions_met {
            if movement.is_running {
                run_event_writer.write(IchunRunEvent {
                    entity,
                    is_running: Some(false),
                });
            }
            continue;
        }

        // Handle toggle mode
        if input.is_running_toggled {
            if input
                .run
                .iter()
                .any(|&key| keyboard_input_res.just_pressed(key))
            {
                run_event_writer.write(IchunRunEvent {
                    entity,
                    is_running: None, // None signals to toggle the current state
                });
            }
            continue;
        }

        // Handle hold-to-run mode
        let run_key_pressed = input.run.iter().any(|&key| keyboard_input_res.pressed(key));

        if movement.is_running != run_key_pressed {
            run_event_writer.write(IchunRunEvent {
                entity,
                is_running: Some(run_key_pressed),
            });
        }
    }
}

fn jump_input_sys(
    mut jump_event_writer: EventWriter<IchunJumpEvent>,
    keyboard_input_res: Res<ButtonInput<KeyCode>>,
    input_handling_res: Res<InputHandling>,
    kcc_qry: Query<(Entity, &KccInputConfig), With<Kcc>>,
) {
    if !input_handling_res.input_handling_active {
        return;
    }

    for (entity, input) in kcc_qry.iter() {
        if !input.input_handling_active {
            continue;
        }

        let jump_pressed = input
            .jump
            .iter()
            .any(|&key| keyboard_input_res.just_pressed(key));

        if jump_pressed {
            jump_event_writer.write(IchunJumpEvent { entity });
        }
    }
}

fn float_input_sys(
    mut float_event_writer: EventWriter<IchunFloatEvent>,
    keyboard_input_res: Res<ButtonInput<KeyCode>>,
    input_handling_res: Res<InputHandling>,
    kcc_qry: Query<(Entity, &KccInputConfig, &KccMovementEventsConfig, &Kcc)>,
) {
    if !input_handling_res.input_handling_active {
        return;
    }

    for (entity, input, movement, kcc) in kcc_qry.iter() {
        if !input.input_handling_active {
            continue;
        }

        // If grounded and currently floating, stop running
        if kcc.is_grounded {
            if movement.is_floating {
                float_event_writer.write(IchunFloatEvent {
                    entity,
                    is_floating: Some(false),
                });
            }
            continue;
        }

        // Handle toggle mode
        if input.is_floating_toggled {
            if input
                .float
                .iter()
                .any(|&key| keyboard_input_res.just_pressed(key))
            {
                float_event_writer.write(IchunFloatEvent {
                    entity,
                    is_floating: None, // None signals to toggle the current state
                });
            }
            continue;
        }

        // Handle hold-to-float mode
        let float_key_pressed = input
            .float
            .iter()
            .any(|&key| keyboard_input_res.pressed(key));

        if movement.is_floating != float_key_pressed {
            float_event_writer.write(IchunFloatEvent {
                entity,
                is_floating: Some(float_key_pressed),
            });
        }
    }
}

fn rotation_input_sys(
    mut look_event_writer: EventWriter<IchunRotateEvent>,
    keyboard_input_res: Res<ButtonInput<KeyCode>>,
    input_handling_res: Res<InputHandling>,
    accumulated_mouse_motion: Res<AccumulatedMouseMotion>,
    kcc_qry: Query<(Entity, &KccInputConfig), With<Kcc>>,
) {
    if !input_handling_res.input_handling_active {
        return;
    }

    let mouse_delta = accumulated_mouse_motion.delta;

    if mouse_delta == Vector2::ZERO {
        return;
    }

    for (entity, input) in kcc_qry.iter() {
        if !input.input_handling_active {
            continue;
        }

        let should_rotate = match &input.rotation_activation {
            Some(activation_keys) => activation_keys
                .iter()
                .any(|&key| keyboard_input_res.pressed(key)),
            None => true,
        };

        if should_rotate {
            look_event_writer.write(IchunRotateEvent {
                entity,
                rotation: mouse_delta,
            });
        }
    }
}