Struct gemini_engine::elements::view::Vec2D

pub struct Vec2D {
    pub x: isize,
    pub y: isize,
}

A pair of isize used for coordinates, size or direction on a 2D plane

Fields

x: isize

y: isize

Implementations

impl Vec2D

pub const ZERO: Vec2D = _

A Vec2D of (0,0)

pub const fn new(x: isize, y: isize) -> Self

Examples found in repository

examples/multi-movement.rs (line 15)

const BLOCK_SIZE: Vec2D = Vec2D::new(4, 2);
const FILL_CHAR: ColChar = ColChar::SOLID;

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

    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 in 0..blocks.len() {
                if i % 2_u32.pow(j as u32) == 0 {
                    blocks[j].pos.x += 1;
                }
            }
        },
        {
            view.clear();
            for block in &blocks {
                view.blit(block, Wrapping::Wrap);
            }
            view.display_render().unwrap();

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

pub fn as_tuple(&self) -> (isize, isize)

Trait Implementations

impl Add<Vec2D> for Vec2D

type Output = Vec2D

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign<Vec2D> for Vec2D

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Vec2D

fn clone(&self) -> Vec2D

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Vec2D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Vec2D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div<isize> for Vec2D

type Output = Vec2D

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl DivAssign<isize> for Vec2D

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<T: Into<isize>> From<(T, T)> for Vec2D

fn from(value: (T, T)) -> Self

Converts to this type from the input type.

impl PartialEq<Vec2D> for Vec2D

fn eq(&self, other: &Vec2D) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Rem<Vec2D> for Vec2D

type Output = Vec2D

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl RemAssign<Vec2D> for Vec2D

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl Sub<Vec2D> for Vec2D

type Output = Vec2D

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SubAssign<Vec2D> for Vec2D

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Vec2D

impl Eq for Vec2D

impl StructuralEq for Vec2D

impl StructuralPartialEq for Vec2D