nightshade 0.13.0

A cross-platform data-oriented game engine.
Documentation 
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use crate::tui::ecs::events::{InputEvent, Message};
use crate::tui::ecs::resources::MouseButton;
use crate::tui::ecs::world::World;
use crate::tui::key_code::KeyCode;
use crossterm::event::{self, Event, KeyEventKind, MouseEventKind};
use std::time::Duration;

fn crossterm_button_to_mouse_button(button: crossterm::event::MouseButton) -> MouseButton {
    match button {
        crossterm::event::MouseButton::Left => MouseButton::Left,
        crossterm::event::MouseButton::Right => MouseButton::Right,
        crossterm::event::MouseButton::Middle => MouseButton::Middle,
    }
}

pub fn poll_input(world: &mut World) {
    world.resources.keyboard.clear_frame();
    world.resources.mouse.clear_frame();

    while let Ok(true) = event::poll(Duration::ZERO) {
        let Ok(event) = event::read() else {
            continue;
        };

        match event {
            Event::Key(key_event) => {
                let key: KeyCode = key_event.code.into();

                match key_event.kind {
                    KeyEventKind::Press => {
                        world.resources.keyboard.pressed.insert(key);
                        world.resources.keyboard.just_pressed.insert(key);
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::KeyPress { key },
                        });
                    }
                    KeyEventKind::Release => {
                        world.resources.keyboard.pressed.remove(&key);
                        world.resources.keyboard.just_released.insert(key);
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::KeyRelease { key },
                        });
                    }
                    KeyEventKind::Repeat => {
                        world.resources.keyboard.just_pressed.insert(key);
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::KeyPress { key },
                        });
                    }
                }
            }
            Event::Mouse(mouse_event) => {
                let column = mouse_event.column;
                let row = mouse_event.row;

                match mouse_event.kind {
                    MouseEventKind::Down(button) => {
                        let button = crossterm_button_to_mouse_button(button);
                        world.resources.mouse.column = column;
                        world.resources.mouse.row = row;
                        match button {
                            MouseButton::Left => {
                                world.resources.mouse.left_pressed = true;
                                world.resources.mouse.left_just_pressed = true;
                            }
                            MouseButton::Right => {
                                world.resources.mouse.right_pressed = true;
                                world.resources.mouse.right_just_pressed = true;
                            }
                            MouseButton::Middle => {
                                world.resources.mouse.middle_pressed = true;
                                world.resources.mouse.middle_just_pressed = true;
                            }
                        }
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::MousePress {
                                button,
                                column,
                                row,
                            },
                        });
                    }
                    MouseEventKind::Up(button) => {
                        let button = crossterm_button_to_mouse_button(button);
                        world.resources.mouse.column = column;
                        world.resources.mouse.row = row;
                        match button {
                            MouseButton::Left => {
                                world.resources.mouse.left_pressed = false;
                                world.resources.mouse.left_just_released = true;
                            }
                            MouseButton::Right => {
                                world.resources.mouse.right_pressed = false;
                                world.resources.mouse.right_just_released = true;
                            }
                            MouseButton::Middle => {
                                world.resources.mouse.middle_pressed = false;
                                world.resources.mouse.middle_just_released = true;
                            }
                        }
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::MouseRelease {
                                button,
                                column,
                                row,
                            },
                        });
                    }
                    MouseEventKind::Moved | MouseEventKind::Drag(_) => {
                        world.resources.mouse.column = column;
                        world.resources.mouse.row = row;
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::MouseMove { column, row },
                        });
                    }
                    MouseEventKind::ScrollUp => {
                        world.resources.mouse.scroll_delta = 1;
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::MouseScroll {
                                delta: 1,
                                column,
                                row,
                            },
                        });
                    }
                    MouseEventKind::ScrollDown => {
                        world.resources.mouse.scroll_delta = -1;
                        world.resources.event_bus.publish(Message::Input {
                            event: InputEvent::MouseScroll {
                                delta: -1,
                                column,
                                row,
                            },
                        });
                    }
                    _ => {}
                }
            }
            Event::Resize(columns, rows) => {
                world.resources.terminal_size.columns = columns;
                world.resources.terminal_size.rows = rows;
                world.resources.event_bus.publish(Message::Input {
                    event: InputEvent::Resize { columns, rows },
                });
            }
            _ => {}
        }
    }
}