Struct Collider 

pub struct Collider {
    pub geometry_type: GeometryType,
    pub position: Vector2<f32>,
    pub scale: Vector2<f32>,
}

Struct to represent the real collider of the object.

Fields

geometry_type: GeometryType

position: Vector2<f32>

scale: Vector2<f32>

Implementations

impl Collider

pub fn new( geometry_type: GeometryType, position: Vector2<f32>, scale: Vector2<f32>, ) -> Self

Create a new collider with parameters.

pub fn new_simple(geometry_type: GeometryType) -> Self

Create a new collider only with the geometry type as a parameter.

Examples found in repository

examples/gravity_simulation.rs (line 25)

fn setup(context: &mut Context) {
    let table: Shape = Shape::new(Orientation::Horizontal, GeometryType::Rectangle, Color::by_option(ColorOption::Black));
    let object: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(Circle::default()), Color::by_option(ColorOption::Blue));

    context.commands.spawn(vec![
        Box::new(table),
        Box::new(Transform::new(
            Position::new(Vector2::new(0.0, -0.70), Strategy::Normalized),
            0.0,
            Vector2::new(0.90, 0.10)
        )),
        Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
    ]);

    context.commands.spawn(vec![
        Box::new(object),
        Box::new(Transform::new(
            Position::new(Vector2::new(400.0, 100.0), Strategy::Pixelated),
            0.0,
            Vector2::new(0.50, 0.50)
        )),
        Box::new(Collision::new(Collider::new_simple(GeometryType::Square))),
        Box::new(Gravity::new(0.0)),
        Box::new(Velocity::new(Vector2::new(0.2, 0.2))),
        Box::new(RigidBody::new(BodyType::Dynamic, 1.0, 0.9, 1.0))
    ]);
}

examples/physics_simulation.rs (line 35)

fn setup(context: &mut Context) {
    let circle: Circle = Circle::new(64, 0.5);
    let red_object: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(circle.clone()), Color::by_option(ColorOption::Red));
    let blue_object: Shape = Shape::new(Orientation::Horizontal, GeometryType::Circle(circle.clone()), Color::by_option(ColorOption::Blue));

    context.commands.spawn(
        vec![
            Box::new(red_object),
            Box::new(Object()),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.30, 0.30)
            )),
            Box::new(Velocity::new(Vector2::new(0.45, 0.45))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(blue_object),
            Box::new(Object()),
            Box::new(Transform::new(
                Position::new(Vector2::new(-0.45, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.30, 0.30)
            )),
            Box::new(Velocity::new(Vector2::new(0.45, 0.45))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, -1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, 1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Vertical, Vector2::new(1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
    spawn_border(context, Orientation::Vertical, Vector2::new(-1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
}

fn update(context: &mut Context) {
    let mut query: Query = Query::new(&context.world).with::<Object>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();

    check_border_collision(context, &entities);
    check_object_collision(context, &entities);
    move_objects(context, &entities);
}

fn spawn_border(context: &mut Context, orientation: Orientation, position: Vector2<f32>, scale: Vector2<f32>) {
    let border: Shape = Shape::new(orientation, GeometryType::Rectangle, Color::by_option(ColorOption::White));

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                scale
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

examples/performance.rs (line 43)

fn setup(context: &mut Context) {
    let circle: Circle = Circle::new(64, 0.5);
    let mut thread_rng: ThreadRng = rng();

    let left_border_perimeter: f64 = -1.3;
    let right_border_perimiter: f64 = 1.3;
    let bottom_border_perimeter: f64 = -0.9;
    let top_border_perimeter: f64 = 0.9;

    // Update the number of spawns for performance benchmarking.
    for _ in 1..=10 {
        let randomic_position_x: f32 = thread_rng.random_range(left_border_perimeter..right_border_perimiter) as f32;
        let randomic_position_y: f32 = thread_rng.random_range(bottom_border_perimeter..top_border_perimeter) as f32;

        let randomic_velocity_x: f32 = thread_rng.random_range(-0.5..0.5) as f32;
        let randomic_velocity_y: f32 = thread_rng.random_range(-0.5..0.5) as f32;

        context.commands.spawn(
            vec![
                Box::new(Shape::new(Orientation::Horizontal, GeometryType::Circle(circle.clone()), Color::by_option(ColorOption::Blue))),
                Box::new(Object()),
                Box::new(Transform::new(
                    Position::new(Vector2::new(randomic_position_x, randomic_position_y), Strategy::Normalized),
                    0.0,
                    Vector2::new(0.15, 0.15)
                )),
                Box::new(Velocity::new(Vector2::new(randomic_velocity_x, randomic_velocity_y))),
                Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
            ]
        );
    }

    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, -1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Horizontal, Vector2::new(0.0, 1.), Vector2::new(context.window_configuration.width as f32, 0.01));
    spawn_border(context, Orientation::Vertical, Vector2::new(1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
    spawn_border(context, Orientation::Vertical, Vector2::new(-1.35, 0.), Vector2::new(0.01, context.window_configuration.height as f32));
}

fn update(context: &mut Context) {
    context.commands.show_fps(context.game_loop_listener.current_fps, Color::by_option(ColorOption::Black));

    let mut query: Query = Query::new(&context.world).with::<Object>();
    let entities: Vec<Entity> = query.entities_with_components().unwrap();

    check_border_collision(context, &entities);
    move_objects(context, &entities);
}

fn spawn_border(context: &mut Context, orientation: Orientation, position: Vector2<f32>, scale: Vector2<f32>) {
    let border: Shape = Shape::new(orientation, GeometryType::Rectangle, Color::by_option(ColorOption::White));

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                scale
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

examples/breakout.rs (line 107)

fn setup(context: &mut Context) {
    let player: Shape = Shape::new(Orientation::Horizontal, GeometryType::Rectangle, Color::by_option(ColorOption::Purple));
    let little_ball: Shape = Shape::new(
        Orientation::Horizontal,
        GeometryType::Circle(Circle::new(64, 0.2)),
        Color::by_option(ColorOption::Black)
    );
    let start_text: Text = Text::new(
        &mut context.render_state,
        Font::new(Fonts::RobotoMonoItalic.get_path(), 40.0),
        Position::new(Vector2::new(298.0, 380.0), Strategy::Pixelated),
        Color::by_option(ColorOption::Black),
        "> enter <".to_string()
    );

    let mut thread_rng: ThreadRng = rand::rng();
    let random_direction: bool = thread_rng.random_bool(1.0 / 3.0);

    let velocity_x: f32 = if random_direction {
        1.2
    } else {
        -1.2
    };

    context.commands.add_resources(vec![
        Box::new(LittleBallRespawnTimer::new()),
        Box::new(NextState::default())
    ]);
    context.commands.spawn(vec![Box::new(start_text)]);

    context.commands.spawn(
        vec![
            Box::new(player),
            Box::new(Player()),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, -0.85), Strategy::Normalized),
                0.0,
                Vector2::new(0.15, 0.10)
            )),
            Box::new(Velocity::new(Vector2::new(2.0, 2.0))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(little_ball),
            Box::new(LittleBall()),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, -0.5), Strategy::Normalized),
                0.0,
                Vector2::new(0.10, 0.10)
            )),
            Box::new(Velocity::new(Vector2::new(velocity_x, -0.5))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    spawn_border(context, Vector2::new(1.05, 0.0));
    spawn_border(context, Vector2::new(-1.05, 0.0));
    spawn_targets(context);
}

fn update(context: &mut Context) {
    let keyboard_input: KeyboardInput = context.world.get_resource_cloned::<KeyboardInput>().unwrap();
    let mouse_input: MouseInput = context.world.get_resource_cloned::<MouseInput>().unwrap();
    let is_hover: bool = mouse_input.mouse_position.x >= 298.0 && (mouse_input.mouse_position.y > 380.0 && mouse_input.mouse_position.y < 416.0);

    if
        keyboard_input.is_key_released(KeyboardKey::Enter) ||
        (mouse_input.is_mouse_button_released(MouseButton::Left) && is_hover)
    {
        let mut next_state: ResourceRefMut<'_, NextState> = context.world.get_resource_mut::<NextState>().unwrap();
        next_state.0 = GameState::Running;

        let mut query: Query = Query::new(&context.world).with::<Text>();
        if let Some(entity) = query.entities_with_components().unwrap().first() {
            context.commands.despawn(entity.clone());
        }
    }

    if context.world.get_resource::<NextState>().unwrap().0 == GameState::Running {
        let mut player_query: Query = Query::new(&context.world).with::<Player>();
        let player_entity: Entity = player_query.entities_with_components().unwrap().first().unwrap().clone();

        let mut little_ball_query: Query = Query::new(&context.world).with::<LittleBall>();
        let little_ball_entity: Entity = little_ball_query.entities_with_components().unwrap().first().unwrap().clone();

        let mut thread_rng: ThreadRng = rand::rng();
        let random_factor: f32 = thread_rng.random_range(-0.5..0.5);

        move_player(context, keyboard_input, player_entity);
        move_little_ball(context, little_ball_entity);
        check_player_little_ball_collision(context, player_entity, little_ball_entity, random_factor);
        check_little_ball_borders_collision(context, little_ball_entity, random_factor);
        check_litte_ball_targets_collision(context, little_ball_entity, random_factor);
        respawn_little_ball_after_outbounds(context, little_ball_entity);
    }
}

fn spawn_border(context: &mut Context, position: Vector2<f32>) {
    let border: Shape = Shape::new(Orientation::Vertical, GeometryType::Rectangle, Color::by_option(ColorOption::Cyan));

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                Vector2::new(0.01, context.window_configuration.height as f32)
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

fn spawn_targets(context: &mut Context) {
    let width: f32 = 0.15;
    let height: f32 = 0.10;

    let rows: i32 = 8;
    let columns: i32 = 10;
    let spacing_x: f32 = 0.09;
    let spacing_y: f32 = 0.02;

    let start_x: f32 = -(columns as f32 * (width + spacing_x)) / 2.0;
    let start_y: f32 = 1.0 - 0.1;

    for row in 0..rows {
        for column in 0..columns {
            let x: f32 = start_x + column as f32 * (width + spacing_x);
            let y: f32 = start_y - row as f32 * (height + spacing_y);

            let mut color: Color = Color::by_option(ColorOption::Red);

            if row == 2 || row == 3 {
                color = Color::by_option(ColorOption::Orange);
            } else if row == 4 || row == 5 {
                color = Color::by_option(ColorOption::Green);
            } else if row == 6 || row == 7 {
                color = Color::by_option(ColorOption::Yellow);
            }

            context.commands.spawn(
                vec![
                    Box::new(Shape::new(Orientation::Horizontal, GeometryType::Rectangle, color)),
                    Box::new(Target()),
                    Box::new(Transform::new(
                        Position::new(Vector2::new(x, y), Strategy::Normalized),
                        0.0,
                        Vector2::new(width, height)
                    )),
                    Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle))),
                ]
            );
        }
    }
}

examples/pong.rs (line 104)

fn setup(context: &mut Context) {
    let gray_racket_sprite: Sprite = Sprite::new("textures/pong/gray_racket_256x256.png".to_string());
    let pink_racket_sprite: Sprite = Sprite::new("textures/pong/pink_racket_256x256.png".to_string());
    let pong_ball_sprite: Sprite = Sprite::new("textures/pong/pong_ball_left_256x256.png".to_string());

    let mut game_audio: GameAudio = GameAudio::default();
    game_audio.0.load_streaming_sound(
        "game_music",
        "audio/pong/soundtrack/arcade_music.ogg",
        AudioSettings::default().loop_region(..).volume(Value::Fixed(Decibels(-10.0)))
    ).ok();
    game_audio.0.play_streaming_sound("game_music".to_string()).ok();

    game_audio.0.load_static_sound(
        "racket_hit",
        "audio/pong/effect/pong_hit.wav",
        AudioSettings::default()
    ).ok();

    context.commands.add_resources(vec![
        Box::new(PongBallRespawnTimer::default()),
        Box::new(game_audio)
    ]);

    spawn_border(context, Vector2::new(0.0, -1.0));
    spawn_border(context, Vector2::new(0.0, 1.0));

    context.commands.spawn(
        vec![
            Box::new(gray_racket_sprite),
            Box::new(Transform::new(
                Position::new(Vector2::new(-1.0, 0.23), Strategy::Normalized),
                0.0,
                Vector2::new(0.55, 0.55)
            )),
            Box::new(Racket()),
            Box::new(GrayRacket()),
            Box::new(Velocity::new(Vector2::new(1.5, 1.5))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(pink_racket_sprite),
            Box::new(Transform::new(
                Position::new(Vector2::new(1.0, 0.25), Strategy::Normalized),
                0.0,
                Vector2::new(0.55, 0.55)
            )),
            Box::new(Racket()),
            Box::new(PinkRacket()),
            Box::new(Velocity::new(Vector2::new(1.5, 1.5))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );

    context.commands.spawn(
        vec![
            Box::new(pong_ball_sprite),
            Box::new(Transform::new(
                Position::new(Vector2::new(0.0, 0.0), Strategy::Normalized),
                0.0,
                Vector2::new(0.55, 0.55)
            )),
            Box::new(PongBall()),
            Box::new(Velocity::new(Vector2::new(1.0, 1.0))),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Square)))
        ]
    );
}

fn update(context: &mut Context) {
    let keyboard_input: KeyboardInput = context.world.get_resource_cloned::<KeyboardInput>().unwrap();

    let mut pong_ball_query: Query = Query::new(&context.world).with::<PongBall>();
    let pong_ball_entities: Vec<Entity> = pong_ball_query.entities_with_components().unwrap();
    let pong_ball: &Entity = pong_ball_entities.first().unwrap();
    let mut thread_rng: ThreadRng = rand::rng();
    let random_factor: f32 = thread_rng.random_range(-0.5..0.5);

    move_gray_racket(context, keyboard_input.clone());
    move_pink_racket(context, keyboard_input.clone());
    move_pong_ball(context, pong_ball);
    check_rackets_ball_collision(context, pong_ball, random_factor);
    check_borders_ball_collision(context, pong_ball, random_factor);
    respawn_pong_ball_after_outbounds(context, pong_ball);
}

fn spawn_border(context: &mut Context, position: Vector2<f32>) {
    let border: Shape = Shape::new(Orientation::Horizontal, GeometryType::Rectangle, Color::by_option(ColorOption::Black));

    context.commands.spawn(
        vec![
            Box::new(border),
            Box::new(Border()),
            Box::new(Transform::new(
                Position::new(position, Strategy::Normalized),
                0.0,
                Vector2::new(context.window_configuration.width as f32, 0.01)
            )),
            Box::new(Collision::new(Collider::new_simple(GeometryType::Rectangle)))
        ]
    );
}

Trait Implementations

impl Clone for Collider

fn clone(&self) -> Collider

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Collider

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

Formats the value using the given formatter.