Enum CollisionShape 

pub enum CollisionShape {
    Circle {
        center: (i32, i32),
        radius: u32,
    },
    Rect {
        center: (i32, i32),
        size: (u32, u32),
    },
    Polygon {
        center: (i32, i32),
        points: Vec<(i32, i32)>,
    },
}

Colliders that attach to GameObjects. Support Circle and Rect colliders

Variants

Circle

Fields

center: (i32, i32)

radius: u32

Rect

Fields

center: (i32, i32)

size: (u32, u32)

Polygon

Fields

center: (i32, i32)

points: Vec<(i32, i32)>

Implementations

impl CollisionShape

pub fn collides_with(&self, other: &CollisionShape) -> bool

Examples found in repository

examples/platformer/game.rs (line 299)

    fn update(
            &mut self, delta: f64,
            _ctl_objs: &Vec<Box<dyn ControlObjectBehavior<Img, Snd, Fnt, Spr, Rm, Data>>>,
            others: &Vec<Box<dyn GameObjectBehavior<Img, Snd, Fnt, Spr, Rm, Data>>>) -> (
                Option<Rm>, Vec<Box<dyn GameObjectBehavior<Img, Snd, Fnt, Spr, Rm, Data>>>
            ) {
        if self.should_reset {
            // We can destroy bricks, so when we reset, we want to respawn the bricks that have
            // been destroyed. It should be all of them, but technically we don't know, so we have
            // to formulaically figure it out.
            let mut existing_bricks = Vec::new();
            for obj in others.iter() {
                if let Data::Brick(id) = obj.state().custom {
                    existing_bricks.push(id);
                }
            }
            let to_respawn = (0..=5).into_iter()
                .map(|id| if !existing_bricks.contains(&id) {
                    Some(
                        Box::new(Brick::new(BRICK_POS[id], id))
                            as Box<dyn GameObjectBehavior<Img, Snd, Fnt, Spr, Rm, Data>>
                    )
                } else {
                    None
                }).filter(|brick| brick.is_some())
                .map(|brick| brick.unwrap())
                .collect::<Vec<Box<_>>>();
            return (Some(Rm::Room0), to_respawn);
        }

        self.state.pos.0 += self.vel.0 * delta;
        self.state.pos.1 += self.vel.1 * delta;

        // Animate
        if let Some(spr) = self.state.sprs.get_mut(&self.state.cur_spr) {
            spr.scale = (0.5, 0.5);
            spr.flip = (!self.facing_right, false);
        }
        if !self.grounded && self.state.cur_spr != Spr::Idle {
            self.state.cur_spr = Spr::Idle;
        } else if self.grounded {
            if self.vel.0.abs() < MOVE_SPD * 0.8 && self.state.cur_spr != Spr::Idle {
                self.state.cur_spr = Spr::Idle;
            } else if self.vel.0.abs() >= MOVE_SPD * 0.8 && self.state.cur_spr != Spr::Walk {
                self.state.cur_spr = Spr::Walk;
                self.facing_right = self.vel.0 > 0.1;
            }
        }

        // Update vel at the end, so collisions can affect it!
        let hor = (if self.right { 1.0 } else { 0.0 }) + (if self.left { -1.0 } else { 0.0 });
        self.vel.0 = ycraft::util::lerp(self.vel.0, hor * MOVE_SPD, ACC * delta);

        if let CollisionShape::Rect { center, size } = self.state.collider {
            let gnd_check = CollisionShape::Rect {
                center: (
                    center.0 + self.state.pos.0 as i32,
                    center.1 + (self.state.pos.1 + self.vel.1 * delta) as i32 + 1
                ), size
            };
            self.grounded = false;
            for other in others.iter() {
                if self.state.pos.1 > other.state().pos.1 - size.1 as f64 * 0.8 {
                    continue;
                }
                if let Data::Brick(_) = other.state().custom {
                    let mut other_col = other.state().collider.clone();
                    if let CollisionShape::Rect { center: ref mut other_center, .. } = other_col {
                        other_center.0 += other.state().pos.0 as i32;
                        other_center.1 += other.state().pos.1 as i32;
                    };
                    if gnd_check.collides_with(&other_col) {
                        if let CollisionShape::Rect { center, size } = other_col {
                            self.grounded = true;
                            self.vel.1 = 0.0;
                            self.state.pos.1 = (center.1 - size.1 as i32 - 1) as f64;
                        }
                    }
                }
            }
        }
        if self.grounded || self.vel.1 > 0.1 {
            self.extra_grav = false;
        }
        if self.extra_grav {
            self.vel.1 += EXTRA_GRAV * delta;
        } else {
            self.vel.1 += GRAVITY * delta;
        }

        (None, vec![])
    }

Trait Implementations

impl Clone for CollisionShape

fn clone(&self) -> CollisionShape

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CollisionShape

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

Formats the value using the given formatter.

impl Ord for CollisionShape

fn cmp(&self, other: &CollisionShape) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for CollisionShape

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for CollisionShape

fn partial_cmp(&self, other: &CollisionShape) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for CollisionShape

impl StructuralPartialEq for CollisionShape