Struct ScreenSize

Source

pub struct ScreenSize {
    pub width: u16,
    pub height: u16,
}

Expand description

A size on screen

Fields§

§width: u16§height: u16

Implementations§

Source §

impl ScreenSize

Source

pub fn new(width: u16, height: u16) -> Self

Examples found in repository ?

examples/simple.rs (line 11)

7fn main() {
8    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
9
10    // Viewport
11    let viewport_size = ScreenSize::new(width / 2, height / 2);
12    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
13
14    // Camera
15    let (width, height) = (width as i64, height as i64);
16    let camera_size = WorldSize::new(width / 2, height / 2);
17    let camera_pos = WorldPos::new(width, height);
18    let camera = Camera::new(camera_pos, camera_size);
19
20    // Renderer
21    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
22    let mut renderer = Renderer::new(stdout_renderer);
23
24    // Player
25    let mut player = ('@', camera_pos);
26
27    let (_, events) = events::<()>(EventModel::Fps(20));
28    for event in events {
29        match event {
30            Event::User(()) => {}
31            Event::Tick => {
32                let pixel = Pixel::new(player.0, camera.to_screen(player.1), None, None);
33                viewport.draw_pixel(pixel);
34                let _ = renderer.render(&mut viewport);
35                viewport.swap_buffers();
36            }
37            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
38            Event::Key(KeyEvent { code: kc, .. }) => {
39                match kc {
40                    KeyCode::Left => { player.1.x -= 1; }
41                    KeyCode::Right => { player.1.x += 1; }
42                    KeyCode::Up => { player.1.y -= 1; }
43                    KeyCode::Down => { player.1.y += 1; }
44                    _ => {}
45                }
46            }
47            Event::Resize(_w, _h) => {}
48        }
49    }
50}

More examples

Hide additional examples

examples/world.rs (line 28)

24fn main() {
25    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
26
27    // Viewport
28    let viewport_size = ScreenSize::new(width / 2, height / 2);
29    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
30    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));
31
32    // Camera
33    let camera_pos = WorldPos::zero();
34    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);
35
36    // Renderer
37    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
38    let mut renderer = Renderer::new(stdout_renderer);
39
40    // Player
41    let mut player = ('@', camera_pos);
42    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);
43
44    // Mob
45    let mut mob = Mob {
46        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
47        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
48        tick: 0,
49    };
50
51    // "Grass"
52    let grass_positions = field_of_grass(&camera);
53    let mut grass = grass_positions.iter().map(|_| Pixel::new(
54        'w',
55        camera.to_screen(camera.position),
56        Some(Color::Green),
57        None
58    )).collect::<Vec<_>>();
59
60    let (_, events) = events::<()>(EventModel::Fps(20));
61    for event in events {
62        match event {
63            Event::User(()) => {}
64            Event::Tick => {
65                viewport.draw_pixels(&grass);
66                viewport.draw_pixel(player_pixel);
67                mob.pixel.pos = camera.to_screen(mob.world_pos);
68                viewport.draw_pixel(mob.pixel);
69
70                // Move the mob to the right
71                mob.update();
72                let camera_border = Border::thin(Some(Color::Green), None);
73                viewport.draw_widget(&camera_border, ScreenPos::zero());
74
75                // Track the player
76                camera.track(player.1);
77                player_pixel.pos = camera.to_screen(player.1);
78                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
79                    grass.pos = camera.to_screen(*world_pos);
80                });
81
82                // Status
83                let status = Text::new(
84                    format!("player x {} | y {}  camera x {} | y {}",
85                        player.1.x,
86                        player.1.y, 
87                        camera.position.x,
88                        camera.position.y,
89                    ),
90                    Some(Color::Red),
91                    None,
92                );
93
94                // Status border
95                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);
96
97                status_viewport.swap_buffers();
98                status_viewport.draw_widget(&status_border, ScreenPos::zero());
99                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
100                let _ = renderer.render(&mut status_viewport);
101
102                // Render and swap the buffers so there is no 
103                // residual characters
104                let _ = renderer.render(&mut viewport);
105                viewport.swap_buffers();
106            }
107            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
108            Event::Key(KeyEvent { code: kc, .. }) => {
109                match kc {
110                    KeyCode::Left => { player.1.x -= 1; }
111                    KeyCode::Right => { player.1.x += 1; }
112                    KeyCode::Up => { player.1.y -= 1; }
113                    KeyCode::Down => { player.1.y += 1; }
114                    _ => {}
115                }
116            }
117            Event::Resize(_w, _h) => {}
118        }
119    }
120}