pomomon-garden/src/features/input/mod.rs

use crate::features::{
    input::utils::mouse_to_grid,
    phase::messages::{NextPhaseMessage, PhaseTimerPauseMessage},
    pom::messages::InvalidMoveMessage,
    shop::ui::open_shop,
    ui::messages::ClosePopupMessage,
};
use crate::prelude::*;
use bevy::input::mouse::MouseButton;
use bevy::window::PrimaryWindow;

pub mod utils;

pub struct InputPlugin;

impl Plugin for InputPlugin {
    fn build(&self, app: &mut App) {
        app.add_message::<MoveMessage>();
        app.add_message::<InvalidMoveMessage>();
        app.add_systems(Update, move_click.run_if(in_state(AppState::GameScreen)));

        app.add_message::<InteractStartMessage>();
        app.add_message::<TileClickMessage>();
        app.add_systems(
            Update,
            interact_click.run_if(in_state(AppState::GameScreen)),
        );

        #[cfg(debug_assertions)]
        app.add_systems(Update, debug_click.run_if(in_state(AppState::GameScreen)));

        app.add_message::<PhaseTimerPauseMessage>();
        app.add_systems(
            Update,
            phase_timer_pause.run_if(in_state(AppState::GameScreen)),
        );

        app.add_message::<NextPhaseMessage>();
        app.add_systems(Update, next_phase.run_if(in_state(AppState::GameScreen)));

        app.add_systems(Update, shop_keybind.run_if(in_state(AppState::GameScreen)));

        app.add_message::<ClosePopupMessage>();
        app.add_systems(Update, popup_keybind);
    }
}

fn move_click(
    mut move_messages: MessageWriter<MoveMessage>,
    mouse_btn: Res<ButtonInput<MouseButton>>,
    window: Single<&Window, With<PrimaryWindow>>,
    camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
    config: Res<GameConfig>,
    phase: Res<CurrentPhase>,
    ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
) {
    match phase.0 {
        Phase::Focus { .. } => return,
        _ => {}
    }

    if mouse_btn.just_pressed(MouseButton::Right) {
        let Some((x, y)) = mouse_to_grid(window, camera, config, ui_query) else {
            return;
        };

        println!("Move Click: ({}, {})", x, y);
        move_messages.write(MoveMessage { x, y });
    }
}

fn interact_click(
    mut tile_click_messages: MessageWriter<TileClickMessage>,
    mouse_btn: Res<ButtonInput<MouseButton>>,
    keys: Res<ButtonInput<KeyCode>>,
    window: Single<&Window, With<PrimaryWindow>>,
    camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
    config: Res<GameConfig>,
    phase: Res<CurrentPhase>,
    ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
) {
    match phase.0 {
        Phase::Focus { .. } => return,
        _ => {}
    }

    if mouse_btn.just_pressed(MouseButton::Left) {
        if keys.pressed(KeyCode::ShiftLeft) || keys.pressed(KeyCode::ShiftRight) {
            return;
        }
        let Some((x, y)) = mouse_to_grid(window, camera, config, ui_query) else {
            return;
        };

        tile_click_messages.write(TileClickMessage { x, y });
    }
}

fn debug_click(
    mouse_btn: Res<ButtonInput<MouseButton>>,
    keys: Res<ButtonInput<KeyCode>>,
    window: Single<&Window, With<PrimaryWindow>>,
    camera: Single<(&Camera, &GlobalTransform), With<Camera2d>>,
    config: Res<GameConfig>,
    phase: Res<CurrentPhase>,
    ui_query: Query<(&ComputedNode, &GlobalTransform), With<Node>>,
    grid: Res<Grid>,
    tile_query: Query<&mut TileState>,
) {
    match phase.0 {
        Phase::Focus { .. } => return,
        _ => {}
    }

    if mouse_btn.just_pressed(MouseButton::Left) {
        if !keys.pressed(KeyCode::ShiftLeft) && !keys.pressed(KeyCode::ShiftRight) {
            return;
        }
        let Some((x, y)) = mouse_to_grid(window, camera, config, ui_query) else {
            return;
        };

        println!("Debug Toggle Click: ({}, {})", x, y);
        grid.map_tile_state(
            (x, y),
            |state| match state {
                TileState::Unclaimed => TileState::Empty,
                TileState::Empty => TileState::Occupied {
                    seed: ItemType::BerrySeed {
                        name: "Debug".into(),
                    },
                    watered: false,
                    growth_stage: 0,
                    withered: false,
                    dry_counter: 0,
                },
                TileState::Occupied { .. } => TileState::Unclaimed,
            },
            tile_query,
        )
        .unwrap_or_else(|_| ());
    }
}

fn phase_timer_pause(
    mut pause_messages: MessageWriter<PhaseTimerPauseMessage>,
    keys: Res<ButtonInput<KeyCode>>,
) {
    if keys.just_pressed(KeyCode::Space) {
        pause_messages.write(PhaseTimerPauseMessage);
    }
}

fn next_phase(mut messages: MessageWriter<NextPhaseMessage>, keys: Res<ButtonInput<KeyCode>>) {
    if keys.just_pressed(KeyCode::Enter) {
        messages.write(NextPhaseMessage);
    }
}

fn shop_keybind(
    keys: Res<ButtonInput<KeyCode>>,
    mut commands: Commands,
    game_config: Res<GameConfig>,
    asset_server: Res<AssetServer>,
) {
    if keys.just_pressed(KeyCode::KeyP) {
        open_shop(&mut commands, &game_config, &asset_server);
    }
}

fn popup_keybind(
    mut close_popup_messages: MessageWriter<ClosePopupMessage>,
    keys: Res<ButtonInput<KeyCode>>,
) {
    if keys.just_pressed(KeyCode::Escape) {
        close_popup_messages.write(ClosePopupMessage);
    }
}