Struct Rect

pub struct Rect {
    pub pos: Vec2D,
    pub size: Vec2D,
    pub fill_char: ColChar,
}

A rectangle primitive which implements CanDraw, and so can be drawn to Canvases

Fields

pos: Vec2D

The position of the top-left corner of the Rect

size: Vec2D

The size of the Rect, extending from pos

fill_char: ColChar

The ColChar used to fill the rectangle

Implementations

impl Rect

pub const fn new(pos: Vec2D, size: Vec2D, fill_char: ColChar) -> Self

Create a new Rect using a position and size

Examples found in repository

examples/multi-movement.rs (line 19)

fn main() {
    let mut view = View::new(50, 12, ColChar::BACKGROUND).with_wrapping_mode(WrappingMode::Wrap);

    let mut blocks = vec![
        Rect::new(Vec2D::new(0, 0), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 2), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 4), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 6), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 8), BLOCK_SIZE, FILL_CHAR),
        Rect::new(Vec2D::new(0, 10), BLOCK_SIZE, FILL_CHAR),
    ];

    let mut i = 0;
    fps_gameloop!(
        {
            i += 1;
            for (j, block) in (0u32..).zip(blocks.iter_mut()) {
                if i % 2_u32.pow(j) == 0 {
                    block.pos.x += 1;
                }
            }
        },
        {
            view.clear();
            for block in &blocks {
                view.draw(block);
            }
            let _ = view.display_render();

            if blocks.iter().all(|b| b.pos.x % view.width as i64 == 0) {
                thread::sleep(Duration::from_secs(2));
            };
        },
        60.0
    );
}

examples/complex-scene.rs (lines 23-27)

fn main() {
    let mut view = View::new(60, 10, BACKGROUND_CHAR);

    let mut pixel = Pixel::new(Vec2D::new(5, 9), FILL_CHAR);

    let mut line = Line::new(Vec2D::new(2, 8), Vec2D::new(28, 7), FILL_CHAR);
    let mut line1_direction = -1;

    let rect = Rect::new(
        Vec2D { x: 11, y: 1 },
        Vec2D { x: 9, y: 3 },
        ColChar::SOLID.with_rgb(200, 30, 0),
    );

    let test_image = r"
  ______
 /|_||_\`.__
(   _    _ _\
=`-(_)--(_)-'   ";
    let mut sprite = Sprite::new(
        Vec2D::new(30, 1),
        test_image,
        Modifier::from_rgb(20, 200, 0),
    );

    let mut draw_elapsed = Duration::default();
    let mut render_elapsed = Duration::default();
    fps_gameloop!(
        {
            pixel.pos.x += 2;
            // loop the position back to the other side. This can be done with `WrappingMode::Wrap` but it won't change the element's actual position, so the pixel position being printed would continue to increase without looping
            pixel.pos %= view.size();

            line.pos1.y += line1_direction;
            line.pos0.y = 10 - line.pos1.y;
            if line.pos1.y > 7 {
                line1_direction = -1;
            } else if line.pos1.y < 3 {
                line1_direction = 1;
            }

            sprite.pos.x += 1;
        },
        {
            view.clear();

            let now = Instant::now();
            view.wrapping_mode = WrappingMode::Panic;
            view.draw(&pixel);
            view.draw(&line);
            view.draw(&rect);
            view.wrapping_mode = WrappingMode::Wrap;
            view.draw(&sprite);
            draw_elapsed = now.elapsed();

            let now = Instant::now();
            let _ = view.display_render();
            render_elapsed = now.elapsed();
        },
        FPS,
        |total_elapsed: Duration, _frame_skip| {
            println!(
                "Drawing: {:.2?} microseconds | Rendering: {:.2?} microseconds| Total: {:.2?}",
                draw_elapsed.as_micros(),
                render_elapsed.as_micros(),
                total_elapsed.as_micros()
            );
            println!("Pixel position: {}", pixel.pos);
        }
    );
}

pub fn new_from_to( top_left: Vec2D, bottom_right: Vec2D, fill_char: ColChar, ) -> Self

Create a new Rect using two positions

pub fn bottom_right(&self) -> Vec2D

Return the coordinates of the bottom right point

Trait Implementations

impl CanCollide for Rect

fn collides_with_pos(&self, pos: Vec2D) -> bool

Returns true if the collider intersects the passed position

impl CanDraw for Rect

fn draw_to(&self, canvas: &mut impl Canvas)

Draw the element to a struct that implements CanDraw