traaains/ui/train/

adding_train.rs

use std::cmp::Ordering;

use bevy::{
    ecs::{
        component::Component,
        entity::Entity,
        event::EntityEvent,
        hierarchy::{ChildOf, Children},
        observer::On,
        query::With,
        system::{Commands, Query, ResMut, Single},
    },
    feathers::{
        constants::icons,
        containers::{
            flex_spacer, group, group_body, group_header, pane, pane_body, pane_header, subpane,
            subpane_body, subpane_header,
        },
        controls::{
            ButtonVariant, FeathersButton, FeathersNumberInput, FeathersSelect, FeathersToolButton,
            NumberInputPrecision, NumberInputValue, OptionIndex, list_rows_from_strings,
        },
        display::{icon, label},
        theme::ThemedText,
    },
    log::tracing,
    picking::events::{PointerEnter, PointerLeave},
    scene::{CommandsSceneExt, Scene, bsn, on},
    state::{state::NextState, state_scoped::DespawnOnExit},
    ui::{
        AlignItems, Display, FlexDirection, JustifyContent, Node, PositionType, percent, px,
        widget::Text,
    },
    ui_widgets::{Activate, ValueChange},
};
use strum::IntoEnumIterator;

use crate::{
    editor::{
        EditorState,
        train::{
            TrainEditorState,
            placing::{
                CurrentPlacingTrain,
                templates::{CarriageBogiesTemplate, CarriageTemplate},
            },
        },
    },
    ui::{EditingWindow, IsHoveringUi, UiState},
};

/// Component identifying a carriage list item with the index of the carriage in [CurrentPlacingTrain].
#[derive(Clone, Component, Default)]
struct CarriageListItem(pub usize);

#[derive(Clone, Component, Default)]
struct CarriagesList;

#[derive(Component)]
pub struct AddingTrainWindow;

/// Find parent with [CarriageListItem] component and returns the index.
fn get_list_item_idx(
    curr_entity: Entity,
    target: &Query<&CarriageListItem>,
    children: &Query<&ChildOf>,
) -> Option<usize> {
    if let Ok(t) = target.get(curr_entity) {
        return Some(t.0);
    }

    if let Ok(child) = children.get(curr_entity) {
        return get_list_item_idx(child.parent(), target, children);
    }

    None
}

fn remove_carriage(
    e: On<Activate>,
    mut cmd: Commands,
    children: Query<&ChildOf>,
    carriages_list: Single<(Entity, &Children), With<CarriagesList>>,
    mut carriage_list_items: Query<&mut CarriageListItem>,
    mut current_placing_train: ResMut<CurrentPlacingTrain>,
) {
    // find our index
    if let Some(target_carriage_idx) = get_list_item_idx(
        e.event_target(),
        &carriage_list_items
            .transmute_lens::<&CarriageListItem>()
            .query(),
        &children,
    ) {
        current_placing_train.carriages.remove(target_carriage_idx);

        for carriage_entity in carriages_list.1.iter() {
            let mut curr_carriage_item = carriage_list_items.get_mut(*carriage_entity).unwrap();
            match curr_carriage_item.0.cmp(&target_carriage_idx) {
                Ordering::Greater => {
                    curr_carriage_item.0 -= 1;
                }
                Ordering::Equal => {
                    cmd.entity(*carriage_entity).despawn();
                }
                _ => {}
            }
        }
    } else {
        tracing::warn!("Failed to remove carriage, failed to find CarriageListItem!");
    }
}

pub fn carriage_list_item(idx: usize, carriage_template: &CarriageTemplate) -> impl Scene {
    let selected_bogie_idx = CarriageBogiesTemplate::iter()
        .enumerate()
        .find_map(|(i, v)| {
            if v == carriage_template.bogies {
                return Some(i);
            }
            None
        });

    bsn! {
        @group()
        CarriageListItem(idx)
        Children [
            @group_header() Children [
                Text("Carriage") ThemedText
                --
                @flex_spacer()
                --
                @FeathersToolButton {
                    @variant: ButtonVariant::Plain,
                }
                Children [
                    @icon(icons::X)
                ]
                on(remove_carriage)
            ]
            --
            @group_body() Children [
                @label("Length (m):")
                --
                @FeathersNumberInput
                NumberInputPrecision(3)
                NumberInputValue::F32({carriage_template.length})
                on(|e: On<ValueChange<f32>>, mut cmd: Commands, target: Query<&CarriageListItem>, children: Query<&ChildOf>, mut res: ResMut<CurrentPlacingTrain>| {
                    if let Some(carriage_idx) = get_list_item_idx(e.event_target(), &target, &children) {
                        cmd.entity(e.event_target()).insert(NumberInputValue::F32(e.value));
                        res.carriages[carriage_idx].length = e.value;
                    } else {
                        tracing::warn!("Failed to update carriage in adding train window, failed to find CarriageListItem!");
                    }
                })
                --
                @label("Width (m):")
                --
                @FeathersNumberInput
                NumberInputPrecision(3)
                NumberInputValue::F32({carriage_template.width})
                on(|e: On<ValueChange<f32>>, mut cmd: Commands, target: Query<&CarriageListItem>, children: Query<&ChildOf>, mut res: ResMut<CurrentPlacingTrain>| {
                    if let Some(carriage_idx) = get_list_item_idx(e.event_target(), &target, &children) {
                        cmd.entity(e.event_target()).insert(NumberInputValue::F32(e.value));
                        res.carriages[carriage_idx].width = e.value;
                    } else {
                        tracing::warn!("Failed to update carriage in adding train window, failed to find CarriageListItem!");
                    }
                })
                --
                @label("Mass (kg):")
                --
                @FeathersNumberInput
                NumberInputPrecision(3)
                NumberInputValue::F32({carriage_template.mass})
                on(|e: On<ValueChange<f32>>, mut cmd: Commands, target: Query<&CarriageListItem>, children: Query<&ChildOf>, mut res: ResMut<CurrentPlacingTrain>| {
                    if let Some(carriage_idx) = get_list_item_idx(e.event_target(), &target, &children) {
                        cmd.entity(e.event_target()).insert(NumberInputValue::F32(e.value));
                        res.carriages[carriage_idx].mass = e.value;
                    } else {
                        tracing::warn!("Failed to update carriage in adding train window, failed to find CarriageListItem!");
                    }
                })
                --
                @label("Power (W):")
                --
                @FeathersNumberInput
                NumberInputPrecision(0)
                NumberInputValue::F32({carriage_template.power})
                on(|e: On<ValueChange<f32>>, mut cmd: Commands, target: Query<&CarriageListItem>, children: Query<&ChildOf>, mut res: ResMut<CurrentPlacingTrain>| {
                    if let Some(carriage_idx) = get_list_item_idx(e.event_target(), &target, &children) {
                        cmd.entity(e.event_target()).insert(NumberInputValue::F32(e.value));
                        res.carriages[carriage_idx].power = e.value;
                    } else {
                        tracing::warn!("Failed to update carriage in adding train window, failed to find CarriageListItem!");
                    }
                })
                --
                @label("Bogies")
                @FeathersSelect {
                    @options: list_rows_from_strings(CarriageBogiesTemplate::iter().map(|s| s.to_string()), selected_bogie_idx),
                }
                on(|e: On<ValueChange<Entity>>, target: Query<&CarriageListItem>, children: Query<&ChildOf>, options: Query<&OptionIndex>, mut res: ResMut<CurrentPlacingTrain>| {
                    if let Some(carriage_idx) = get_list_item_idx(e.event_target(), &target, &children) {
                        if let Ok(option) = options.get(e.value) {
                            res.carriages[carriage_idx].bogies = CarriageBogiesTemplate::iter().nth(option.0).unwrap();
                        }
                    } else {
                        tracing::warn!("Failed to update carriage in adding train window, failed to find CarriageListItem!");
                    }
                })
            ]
        ]
    }
}

fn submit_add_train(
    _: On<Activate>,
    mut n_ui_state: ResMut<NextState<UiState>>,
    mut n_edit_state: ResMut<NextState<EditorState>>,
    mut n_track_edit_state: ResMut<NextState<TrainEditorState>>,
) {
    // state galore
    n_ui_state.set(UiState::Default);
    n_edit_state.set(EditorState::Train);
    n_track_edit_state.set(TrainEditorState::PlacingTrain);
}

pub fn adding_train_window(starting_template: &CurrentPlacingTrain) -> impl Scene {
    let starting_carriages: Vec<_> = starting_template
        .carriages
        .iter()
        .enumerate()
        .map(|(i, t)| carriage_list_item(i, t))
        .collect();

    bsn! {
        EditingWindow
        Node {
            position_type: PositionType::Absolute,
            top: px(16),
            left: px(16),
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            align_items: AlignItems::Stretch,
            justify_content: JustifyContent::Start,
            width: percent(20),
            min_width: px(200),
            max_height: percent(80)
        }
        DespawnOnExit<UiState>(UiState::AddingTrain)
        Children [
            @pane() Children [
                @pane_header() Children [ Text("Adding train") ThemedText ]
                --
                @pane_body() Children [
                    @FeathersButton {
                        @caption: bsn! { Text("Add carriage") ThemedText }
                    }
                    on(|_: On<Activate>, mut cmd: Commands, carriages_list: Single<Entity, With<CarriagesList>>, mut res: ResMut<CurrentPlacingTrain>| {
                        let template = CarriageTemplate::default();
                        let spawned_item = cmd.spawn_scene(carriage_list_item(res.carriages.len(), &template)).id();
                        res.carriages.push(template);
                        cmd.entity(*carriages_list).add_child(spawned_item);
                    })
                    --
                    @subpane()
                    Children [
                        @subpane_header() Children [ Text("Carriages") ThemedText ]
                        --
                        @subpane_body()
                        CarriagesList
                        Children [{starting_carriages}]
                    ]
                    --
                    @FeathersButton {
                        @caption: bsn! { Text("Add train") ThemedText }
                    }
                    on(submit_add_train)
                ]
            ]
        ]
        on(|_: On<PointerEnter>, mut next_state: ResMut<NextState<IsHoveringUi>>| {
            next_state.set(IsHoveringUi(true));
        })
        on(|_: On<PointerLeave>, mut next_state: ResMut<NextState<IsHoveringUi>>| {
            next_state.set(IsHoveringUi(false));
        })
    }
}