bevy/examples/game/breakout.rs
2020-07-16 18:26:21 -07:00

256 lines
8.1 KiB
Rust

use bevy::{
prelude::*,
render::pass::ClearColor,
sprite::collide_aabb::{collide, Collision},
};
fn main() {
App::build()
.add_default_plugins()
.add_resource(Scoreboard { score: 0 })
.add_resource(ClearColor(Color::rgb(0.7, 0.7, 0.7)))
.add_startup_system(setup.system())
.add_system(paddle_movement_system.system())
.add_system(ball_collision_system.system())
.add_system(ball_movement_system.system())
.add_system(scoreboard_system.system())
.run();
}
struct Paddle {
speed: f32,
}
struct Ball {
velocity: Vec3,
}
struct Scoreboard {
score: usize,
}
struct Brick;
struct Wall;
fn setup(
mut commands: Commands,
mut materials: ResMut<Assets<ColorMaterial>>,
asset_server: Res<AssetServer>,
) {
// Add the game's entities to our world
commands
// camera
.spawn(OrthographicCameraComponents::default())
// paddle
.spawn(SpriteComponents {
material: materials.add(Color::rgb(0.2, 0.2, 0.8).into()),
translation: Translation(Vec3::new(0.0, -250.0, 0.0)),
sprite: Sprite {
size: Vec2::new(120.0, 30.0),
},
..Default::default()
})
.with(Paddle { speed: 500.0 })
// ball
.spawn(SpriteComponents {
material: materials.add(Color::rgb(0.8, 0.2, 0.2).into()),
translation: Translation(Vec3::new(0.0, -100.0, 1.0)),
sprite: Sprite {
size: Vec2::new(30.0, 30.0),
},
..Default::default()
})
.with(Ball {
velocity: 400.0 * Vec3::new(0.5, -0.5, 0.0).normalize(),
})
// scoreboard
.spawn(LabelComponents {
label: Label {
font: asset_server.load("assets/fonts/FiraSans-Bold.ttf").unwrap(),
text: "Score:".to_string(),
style: TextStyle {
color: Color::rgb(0.2, 0.2, 0.8).into(),
font_size: 40.0,
},
},
node: Node::new(Anchors::TOP_LEFT, Margins::new(10.0, 50.0, 10.0, 50.0)),
..Default::default()
});
// Add walls
let wall_material = materials.add(Color::rgb(0.5, 0.5, 0.5).into());
let wall_thickness = 10.0;
let bounds = Vec2::new(900.0, 600.0);
commands
// left
.spawn(SpriteComponents {
material: wall_material,
translation: Translation(Vec3::new(-bounds.x() / 2.0, 0.0, 0.0)),
sprite: Sprite {
size: Vec2::new(wall_thickness, bounds.y() + wall_thickness),
},
..Default::default()
})
.with(Wall)
// right
.spawn(SpriteComponents {
material: wall_material,
translation: Translation(Vec3::new(bounds.x() / 2.0, 0.0, 0.0)),
sprite: Sprite {
size: Vec2::new(wall_thickness, bounds.y() + wall_thickness),
},
..Default::default()
})
.with(Wall)
// bottom
.spawn(SpriteComponents {
material: wall_material,
translation: Translation(Vec3::new(0.0, -bounds.y() / 2.0, 0.0)),
sprite: Sprite {
size: Vec2::new(bounds.x() + wall_thickness, wall_thickness),
},
..Default::default()
})
.with(Wall)
// top
.spawn(SpriteComponents {
material: wall_material,
translation: Translation(Vec3::new(0.0, bounds.y() / 2.0, 0.0)),
sprite: Sprite {
size: Vec2::new(bounds.x() + wall_thickness, wall_thickness),
},
..Default::default()
})
.with(Wall);
// Add bricks
let brick_rows = 4;
let brick_columns = 5;
let brick_spacing = 20.0;
let brick_size = Vec2::new(150.0, 30.0);
let bricks_width = brick_columns as f32 * (brick_size.x() + brick_spacing) - brick_spacing;
// center the bricks and move them up a bit
let bricks_offset = Vec3::new(-(bricks_width - brick_size.x()) / 2.0, 100.0, 0.0);
for row in 0..brick_rows {
let y_position = row as f32 * (brick_size.y() + brick_spacing);
for column in 0..brick_columns {
let brick_position = Vec3::new(
column as f32 * (brick_size.x() + brick_spacing),
y_position,
0.0,
) + bricks_offset;
commands
// brick
.spawn(SpriteComponents {
material: materials.add(Color::rgb(0.2, 0.2, 0.8).into()),
sprite: Sprite { size: brick_size },
translation: Translation(brick_position),
..Default::default()
})
.with(Brick);
}
}
}
fn paddle_movement_system(
time: Res<Time>,
keyboard_input: Res<Input<KeyCode>>,
mut query: Query<(&Paddle, &mut Translation)>,
) {
for (paddle, translation) in &mut query.iter() {
let mut direction = 0.0;
if keyboard_input.pressed(KeyCode::Left) {
direction -= 1.0;
}
if keyboard_input.pressed(KeyCode::Right) {
direction += 1.0;
}
*translation.0.x_mut() += time.delta_seconds * direction * paddle.speed;
}
}
fn ball_movement_system(time: Res<Time>, mut ball_query: Query<(&Ball, &mut Translation)>) {
for (ball, translation) in &mut ball_query.iter() {
translation.0 += ball.velocity * time.delta_seconds;
}
}
fn scoreboard_system(scoreboard: Res<Scoreboard>, mut query: Query<&mut Label>) {
for mut label in &mut query.iter() {
label.text = format!("Score: {}", scoreboard.score);
}
}
fn ball_collision_system(
mut commands: Commands,
mut scoreboard: ResMut<Scoreboard>,
mut ball_query: Query<(&mut Ball, &Translation, &Sprite)>,
mut paddle_query: Query<(&Paddle, &Translation, &Sprite)>,
mut brick_query: Query<(Entity, &Brick, &Translation, &Sprite)>,
mut wall_query: Query<(&Wall, &Translation, &Sprite)>,
) {
for (ball, translation, sprite) in &mut ball_query.iter() {
let ball_position = translation.0;
let ball_size = sprite.size;
let velocity = &mut ball.velocity;
let mut collision = None;
// check collision with walls
for (_wall, translation, sprite) in &mut wall_query.iter() {
if collision.is_some() {
break;
}
collision = collide(ball_position, ball_size, translation.0, sprite.size);
}
// check collision with paddle(s)
for (_paddle, translation, sprite) in &mut paddle_query.iter() {
if collision.is_some() {
break;
}
collision = collide(ball_position, ball_size, translation.0, sprite.size);
}
// check collision with bricks
for (brick_entity, _brick, translation, sprite) in &mut brick_query.iter() {
if collision.is_some() {
break;
}
collision = collide(ball_position, ball_size, translation.0, sprite.size);
if collision.is_some() {
scoreboard.score += 1;
commands.despawn(brick_entity);
}
}
// reflect the ball when it collides
let mut reflect_x = false;
let mut reflect_y = false;
// only reflect if the ball's velocity is going in the opposite direction of the collision
match collision {
Some(Collision::Left) => reflect_x = velocity.x() > 0.0,
Some(Collision::Right) => reflect_x = velocity.x() < 0.0,
Some(Collision::Top) => reflect_y = velocity.y() < 0.0,
Some(Collision::Bottom) => reflect_y = velocity.y() > 0.0,
None => {}
}
// reflect velocity on the x-axis if we hit something on the x-axis
if reflect_x {
*velocity.x_mut() = -velocity.x();
}
// reflect velocity on the y-axis if we hit something on the y-axis
if reflect_y {
*velocity.y_mut() = -velocity.y();
}
}
}