Struct console_engine::ConsoleEngine

pub struct ConsoleEngine {
    pub frame_count: usize,
    // some fields omitted
}

Console Engine Framework

Fields

frame_count: usize

The current frame count, publicly accessible

Methods

impl ConsoleEngine

Basic Usage :

use console_engine::pixel;
use console_engine::termion::color;
use console_engine::termion::event::Key;
 
fn main() {
    // initializes a screen of 20x10 characters with a target of 3 frame per second
    // coordinates will range from [0,0] to [19,9]
    let mut engine = console_engine::ConsoleEngine::init(20, 10, 3);
    let value = 14;
    // main loop, be aware that you'll have to break it because ctrl+C is captured
    loop {
        engine.wait_frame(); // wait for next frame + capture inputs
        engine.clear_screen(); // reset the screen
     
        engine.line(0, 0, 19, 9, pixel::pxl('#')); // draw a line of '#' from [0,0] to [19,9]
        engine.print(0, 4, format!("Result: {}", value)); // prints some value at [0,4]
     
        engine.set_pxl(4, 0, pixel::pxl_fg('O', color::Cyan)); // write a majestic cyan 'O' at [4,0]
 
        if engine.is_key_pressed(Key::Char('q')) { // if the user presses 'q' :
            break; // exits app
        }
     
        engine.draw(); // draw the screen
    }
}

pub fn init(width: u32, height: u32, target_fps: u32) -> ConsoleEngine

Initialize a screen of the provided width and height, and load the target FPS

pub fn init_fill(target_fps: u32) -> ConsoleEngine

Initialize a screen filling the entire terminal with the target FPS

pub fn init_fill_require(
    width: u32,
    height: u32,
    target_fps: u32
) -> ConsoleEngine

Initialize a screen filling the entire terminal with the target FPS
Also check the terminal width and height and assert if the terminal has at least the asked size

pub fn scr_w(&self) -> u32

Get the screen width

pub fn scr_h(&self) -> u32

Get the screen height

pub fn clear_screen(&mut self)

Reset the screen to a blank state

pub fn print(&mut self, x: i32, y: i32, string: String)

prints a string at the specified coordinates.
The string will be cropped if it reach the right border

usage:

engine.print(0,0, String::from("Hello, world!"));
engine.print(0, 4, format!("Score: {}", score));

pub fn print_fbg<C1: Color + Clone, C2: Color + Clone>(
    &mut self,
    x: i32,
    y: i32,
    string: String,
    fg: C1,
    bg: C2
)

prints a string at the specified coordinates with the specified foreground and background color
The string will automatically overlaps if it reach the right border

usage

// print "Hello, world" in blue on white background
engine.print(0,0, String::from("Hello, world!"), color::Blue, color::White);

pub fn line(
    &mut self,
    start_x: i32,
    start_y: i32,
    end_x: i32,
    end_y: i32,
    character: Pixel
)

draws a line of the provided character between two sets of coordinates
see: Bresenham's line algorithm

Note : Your line can start or end out of bounds. These pixels won't be drawn

usage :

use console_engine::pixel;
// ...
engine.line(0, 0, 9, 9, pixel::pxl('#'));

pub fn rect(
    &mut self,
    start_x: i32,
    start_y: i32,
    end_x: i32,
    end_y: i32,
    character: Pixel
)

Draws a rectangle of the provided character between two sets of coordinates

usage :

use console_engine::pixel;
// ...
engine.rect(0, 0, 9, 9, pixel::pxl('#'));

pub fn fill_rect(
    &mut self,
    start_x: i32,
    start_y: i32,
    end_x: i32,
    end_y: i32,
    character: Pixel
)

Fill a rectangle of the provided character between two sets of coordinates

usage :

use console_engine::pixel;
// ...
engine.fill_rect(0, 0, 9, 9, pixel::pxl('#'));

pub fn circle(&mut self, x: i32, y: i32, radius: u32, character: Pixel)

Draws a circle of the provided character at an x and y position with a radius see: olcPixelGameEngine Repository

usage :

use console_engine::pixel;
// ...
engine.circle(10, 10, 4, pixel::pxl('#'));

pub fn fill_circle(&mut self, x: i32, y: i32, radius: u32, character: Pixel)

Fill a circle of the provided character at an x and y position with a radius see: olcPixelGameEngine Repository

usage :

use console_engine::pixel;
// ...
engine.circle(10, 10, 4, pixel::pxl('#'));

pub fn triangle(
    &mut self,
    x1: i32,
    y1: i32,
    x2: i32,
    y2: i32,
    x3: i32,
    y3: i32,
    character: Pixel
)

Draws a triangle of the provided character using three sets of coordinates

usage :

use console_engine::pixel;
// ...
engine.triangle(8,8, 4,6, 9,2, pixel::pxl('#'));

pub fn fill_triangle(
    &mut self,
    x1: i32,
    y1: i32,
    x2: i32,
    y2: i32,
    x3: i32,
    y3: i32,
    character: Pixel
)

Fill a triangle of the provided character using three sets of coordinates see: rustyPixelGameEngine Repository

usage :

use console_engine::pixel;
// ...
engine.fill_triangle(8,8, 4,6, 9,2, pixel::pxl('#'));

pub fn set_pxl(&mut self, x: i32, y: i32, character: Pixel)

sets the provided character in the specified coordinates out of bounds pixels will be ignored

usage:

use console_engine::pixel;
// ...
engine.set_pxl(3,8,pixel::pixel('o'));

pub fn get_pxl(&self, x: i32, y: i32) -> Result<Pixel, String>

Get the character stored at provided coordinates

usage:

if engine.get_pxl(3,8).unwrap().chr == 'o' {
    engine.print(0,0,"Found a 'o'");
}

pub fn draw(&mut self)

Draw the screen in the terminal
For best results, use it once per frame

usage:

engine.print(0,0,String::from("Hello, world!")); // <- prints "Hello, world!" in 'screen' memory
engine.draw(); // display 'screen' memory to the user's terminal

pub fn wait_frame(&mut self)

Pause the execution until the next frame need to be rendered
Internally gets user's input for the next frame

usage:

// initializes a screen with a 10x10 screen and targetting 30 fps
let mut engine = console_engine::ConsoleEngine::init(10, 10, 30);
loop {
    engine.wait_frame(); // wait for next frame
    // do your stuff
}

pub fn is_key_pressed(&self, key: Key) -> bool

checks whenever a key is pressed (first frame held only)

usage:

loop {
    engine.wait_frame(); // wait for next frame + captures input
     
    if engine.is_key_pressed(Key::Char('q')) {
        break; // exits app
    }
}

pub fn is_key_held(&self, key: Key) -> bool

checks whenever a key is held down

usage:

loop {
    engine.wait_frame(); // wait for next frame + captures input
     
    if engine.is_key_held(Key::Char('8')) && pos_y > 0 {
        pos_y -= 1; // move position upward
    }
}

pub fn is_key_released(&self, key: Key) -> bool

checks whenever a key has been released (first frame released)

usage:

if engine.is_key_held(Key::Char('h')) {
    engine.clear_screen();
    engine.print(0,0,"Please don't hold this button.");
    engine.draw();
    while !engine.is_key_released(Key::Char('h')) {
        engine.wait_frame(); // refresh button's states
    }
}

pub fn get_mouse_press(&self, button: MouseButton) -> Option<(u32, u32)>

Give the mouse's terminal coordinates if the provided button has been pressed

usage :

// prints a 'P' where the mouse's left button has been pressed
let mouse_pos = engine.get_mouse_press(termion::event::MouseButton::Left);
if mouse_pos.is_some() {
   let mouse_pos = mouse_pos.unwrap();
   engine.set_pxl(mouse_pos.0 as i32, mouse_pos.1 as i32, pixel::pxl('P'));
}

pub fn get_mouse_held(&self) -> Option<(u32, u32)>

Give the mouse's terminal coordinates if a button is held on the mouse

usage :

// prints a 'H' where the mouse is currently held
let mouse_pos = engine.get_mouse_held();
if mouse_pos.is_some() {
    let mouse_pos = mouse_pos.unwrap();
    engine.set_pxl(mouse_pos.0 as i32, mouse_pos.1 as i32, pixel::pxl('H'));
}

pub fn get_mouse_released(&self) -> Option<(u32, u32)>

Give the mouse's terminal coordinates if a button has been released on the mouse

usage :

// prints a 'R' where the mouse has been released
let mouse_pos = engine.get_mouse_held();
if mouse_pos.is_some() {
    let mouse_pos = mouse_pos.unwrap();
    engine.set_pxl(mouse_pos.0 as i32, mouse_pos.1 as i32, pixel::pxl('H'));
}

pub fn debug_keys(&self)

prints key status on screen. For debug purposes only.

Trait Implementations

impl Drop for ConsoleEngine

fn drop(&mut self)

Executes the destructor for this type.