Struct StdoutTarget

pub struct StdoutTarget { /* private fields */ }

Render to stdout

Implementations

impl StdoutTarget

pub fn new() -> Result<Self>

Create a new stdout target. This sets up the terminal so tinybit can draw on it. That includes:

• Enabling raw mode
• Entering an alternate screen
• Hiding the cursor
• Clearing the screen

Once this is dropped it will reset all these settings.

Examples found in repository

examples/simple.rs (line 21)

fn main() {
    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");

    // Viewport
    let viewport_size = ScreenSize::new(width / 2, height / 2);
    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);

    // Camera
    let (width, height) = (width as i64, height as i64);
    let camera_size = WorldSize::new(width / 2, height / 2);
    let camera_pos = WorldPos::new(width, height);
    let camera = Camera::new(camera_pos, camera_size);

    // Renderer
    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
    let mut renderer = Renderer::new(stdout_renderer);

    // Player
    let mut player = ('@', camera_pos);

    let (_, events) = events::<()>(EventModel::Fps(20));
    for event in events {
        match event {
            Event::User(()) => {}
            Event::Tick => {
                let pixel = Pixel::new(player.0, camera.to_screen(player.1), None, None);
                viewport.draw_pixel(pixel);
                let _ = renderer.render(&mut viewport);
                viewport.swap_buffers();
            }
            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
            Event::Key(KeyEvent { code: kc, .. }) => {
                match kc {
                    KeyCode::Left => { player.1.x -= 1; }
                    KeyCode::Right => { player.1.x += 1; }
                    KeyCode::Up => { player.1.y -= 1; }
                    KeyCode::Down => { player.1.y += 1; }
                    _ => {}
                }
            }
            Event::Resize(_w, _h) => {}
        }
    }
}

examples/world.rs (line 37)

fn main() {
    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");

    // Viewport
    let viewport_size = ScreenSize::new(width / 2, height / 2);
    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));

    // Camera
    let camera_pos = WorldPos::zero();
    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);

    // Renderer
    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
    let mut renderer = Renderer::new(stdout_renderer);

    // Player
    let mut player = ('@', camera_pos);
    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);

    // Mob
    let mut mob = Mob {
        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
        tick: 0,
    };

    // "Grass"
    let grass_positions = field_of_grass(&camera);
    let mut grass = grass_positions.iter().map(|_| Pixel::new(
        'w',
        camera.to_screen(camera.position),
        Some(Color::Green),
        None
    )).collect::<Vec<_>>();

    let (_, events) = events::<()>(EventModel::Fps(20));
    for event in events {
        match event {
            Event::User(()) => {}
            Event::Tick => {
                viewport.draw_pixels(&grass);
                viewport.draw_pixel(player_pixel);
                mob.pixel.pos = camera.to_screen(mob.world_pos);
                viewport.draw_pixel(mob.pixel);

                // Move the mob to the right
                mob.update();
                let camera_border = Border::thin(Some(Color::Green), None);
                viewport.draw_widget(&camera_border, ScreenPos::zero());

                // Track the player
                camera.track(player.1);
                player_pixel.pos = camera.to_screen(player.1);
                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
                    grass.pos = camera.to_screen(*world_pos);
                });

                // Status
                let status = Text::new(
                    format!("player x {} | y {}  camera x {} | y {}",
                        player.1.x,
                        player.1.y, 
                        camera.position.x,
                        camera.position.y,
                    ),
                    Some(Color::Red),
                    None,
                );

                // Status border
                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);

                status_viewport.swap_buffers();
                status_viewport.draw_widget(&status_border, ScreenPos::zero());
                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
                let _ = renderer.render(&mut status_viewport);

                // Render and swap the buffers so there is no 
                // residual characters
                let _ = renderer.render(&mut viewport);
                viewport.swap_buffers();
            }
            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
            Event::Key(KeyEvent { code: kc, .. }) => {
                match kc {
                    KeyCode::Left => { player.1.x -= 1; }
                    KeyCode::Right => { player.1.x += 1; }
                    KeyCode::Up => { player.1.y -= 1; }
                    KeyCode::Down => { player.1.y += 1; }
                    _ => {}
                }
            }
            Event::Resize(_w, _h) => {}
        }
    }
}

Trait Implementations

impl Drop for StdoutTarget

fn drop(&mut self)

Executes the destructor for this type.

impl RenderTarget for StdoutTarget

fn render<'a, P: Iterator<Item = &'a Pixel>>(&'a mut self, pixels: P)

fn clear(&mut self)