summaryrefslogtreecommitdiffstats
path: root/src/window/ui.rs
blob: 60cd795089f1fb81b5689948c9121b7a9fef8bff (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
use std::cell::RefCell;

use cgmath::Vector3;

use crate::{GameState, eguictx::EguiCtx, solar_system, timeman::{Second, TimeMan}};

#[derive(Default, Clone)]
pub struct GameWindowUiState
{
    pub current_system: Option<solar_system::SystemId>,
    pub camera_scale: f32,
    pub camera_pos: Option<cgmath::Point3<f32>>,
    pub camera_target: Option<solar_system::BodyId>,
    pub auto_time: Option<Second>,
    pub do_auto_tick: bool
}

impl GameWindowUiState
{
    pub fn render(
        old_state: &GameWindowUiState,
        game_state: &RefCell<GameState>,
        eguictx: &EguiCtx)
    -> Self
    {
        let mut new_state = old_state.clone();

        { GameWindowUiState::render_topbar(&mut new_state, game_state, eguictx); }

        new_state
    }

    fn render_topbar(
        state: &mut GameWindowUiState,
        game_state: &RefCell<GameState>,
        eguictx: &EguiCtx)
    {
        let mut game_state = game_state.borrow_mut();

        egui::TopBottomPanel::top("topbar").show(
            eguictx.context(),
            |ui| {

            ui.horizontal(|ui| {
                let solar_systems = game_state.solar_systems();
                let selected_system_label = match state.current_system {
                    Some(id) => solar_systems[id].name(),
                    None => ""
                };

                egui::ComboBox::from_label("Current System")
                    .selected_text(selected_system_label)
                    .show_ui(ui, |ui| {
                
                    for (i, system) in solar_systems.iter().enumerate() {
                        ui.selectable_value(
                            &mut state.current_system,
                            Some(i),
                            system.name()
                        );
                    }
                });

                let current_system = match state.current_system {
                    Some(id) => &solar_systems[id],
                    None => return
                };

                let selected_body_label = match state.camera_target {
                    Some(id) => current_system.bodies()[id].name(),
                    None => ""
                };

                ui.separator();

                egui::ComboBox::from_label("Camera Target")
                    .selected_text(selected_body_label)
                    .show_ui(ui, |ui| {

                    for (i, body) in current_system.bodies().iter().enumerate() {
                        ui.selectable_value(
                            &mut state.camera_target,
                            Some(i),
                            body.name());
                    }
                });

                match state.camera_pos {
                    Some(pos) => { ui.label(format!("Pos x{} y{} z{}", pos.x, pos.y, pos.z)); },
                    None => {}
                }
            });

            ui.horizontal(|ui| {
                ui.label(format!("Time: {}", TimeMan::format_duration(game_state.timeman().seconds())));
                
                let button_seconds = [1, 5, 30, 60, 60*5, 60*30, 60*60, 60*60*24, 60*60*24*5, 60*60*24*30];
                let selected_button = state.auto_time;

                button_seconds.iter().for_each(|&seconds| {
                    ui.vertical(|ui| {
                        let auto_selected = match selected_button {
                            Some(o) => o == seconds,
                            None => false
                        };
                        let label = TimeMan::format_duration(seconds);

                        if ui.button(label.clone()).clicked() {
                            game_state.timeman_mut().advance(seconds);
                        }

                        if ui.add(egui::Button::new(label.clone()).selected(auto_selected)).clicked() {
                            state.auto_time = Some(seconds);
                        }
                    });
                });
            });
        });
    }
}