├── assets
    ├── bird.png
    ├── pipe.png
    ├── cloud_1.png
    ├── cloud_2.png
    ├── mountain.png
    ├── GameOverText.png
    ├── SpaceToStart.png
    └── fonts
    │   └── Kenney Future Narrow.ttf
├── flappy_bevy_preview.gif
├── src
    ├── gamedata.rs
    ├── physics.rs
    ├── bounds_deletion.rs
    ├── screens.rs
    ├── main.rs
    ├── clouds.rs
    ├── animation.rs
    ├── gamestate.rs
    ├── mountains.rs
    ├── pipes.rs
    └── bird.rs
├── LICENSE
├── .gitignore
├── Cargo.toml
├── .vscode
    └── launch.json
└── README.md


/assets/bird.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/bird.png


--------------------------------------------------------------------------------
/assets/pipe.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/pipe.png


--------------------------------------------------------------------------------
/assets/cloud_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/cloud_1.png


--------------------------------------------------------------------------------
/assets/cloud_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/cloud_2.png


--------------------------------------------------------------------------------
/assets/mountain.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/mountain.png


--------------------------------------------------------------------------------
/assets/GameOverText.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/GameOverText.png


--------------------------------------------------------------------------------
/assets/SpaceToStart.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/SpaceToStart.png


--------------------------------------------------------------------------------
/flappy_bevy_preview.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/flappy_bevy_preview.gif


--------------------------------------------------------------------------------
/assets/fonts/Kenney Future Narrow.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TanTanDev/flappy_bevy/HEAD/assets/fonts/Kenney Future Narrow.ttf


--------------------------------------------------------------------------------
/src/gamedata.rs:
--------------------------------------------------------------------------------
1 | use crate::gamestate;
2 | use gamestate::GameState;
3 | 
4 | pub struct GameData {
5 |     pub game_state: GameState,
6 |     pub score: i32,
7 | }
8 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | flappy_bevy is dual-licensed under either
2 | 
3 | * MIT License (docs/LICENSE-MIT or http://opensource.org/licenses/MIT)
4 | * Apache License, Version 2.0 (docs/LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
5 | 
6 | at your option.
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Generated by Cargo
 2 | # will have compiled files and executables
 3 | /target/
 4 | 
 5 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 6 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 7 | Cargo.lock
 8 | 
 9 | # These are backup files generated by rustfmt
10 | **/*.rs.bk
11 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "flappy_bevy"
 3 | version = "0.1.0"
 4 | authors = ["TanTanDev"]
 5 | edition = "2018"
 6 | 
 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 8 | 
 9 | [dependencies]
10 | #bevy = "0.1.2"
11 | bevy = {git = "https://github.com/bevyengine/bevy.git", rev = "25f62f72"}
12 | rand = "0.7.3"
13 | 
14 | # Override breaking change, transitive via bevy_asset, which auto-resolves to 5.0.0-pre.13
15 | notify = "=5.0.0-pre.2"


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Use IntelliSense to learn about possible attributes.
 3 |     // Hover to view descriptions of existing attributes.
 4 |     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         {
 8 |             "type": "lldb",
 9 |             "request": "launch",
10 |             "name": "Debug",
11 |             "program": "${workspaceFolder}/target/debug/flappy_bevy.exe",
12 |             "args": [],
13 |             "cwd": "${workspaceFolder}"
14 |         }
15 |     ]
16 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ![](flappy_bevy_preview.gif)
 2 | 
 3 | A game like flappy bird made for the bevy engine
 4 | 
 5 | License
 6 | 
 7 | flappy bevy is free and open source! All code in this repository is dual-licensed under either:
 8 | 
 9 | * MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)
10 | * Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
11 | 
12 | Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
13 | 


--------------------------------------------------------------------------------
/src/physics.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | pub struct Velocity(pub Vec2);
 4 | 
 5 | pub struct Gravity(pub f32);
 6 | pub struct AffectedByGravity;
 7 | 
 8 | pub struct PhysicsPlugin;
 9 | 
10 | impl Plugin for PhysicsPlugin {
11 |     fn build(&self, app: &mut AppBuilder) {
12 |         app.add_system(velocity_system.system())
13 |             .add_system(gravity_system.system());
14 |     }
15 | }
16 | 
17 | fn gravity_system(
18 |     gravity: Res<Gravity>,
19 |     time: Res<Time>,
20 |     _affected_by_gravity: &AffectedByGravity,
21 |     mut velocity: Mut<Velocity>,
22 | ) {
23 |     *velocity.0.y_mut() -= gravity.0 * time.delta_seconds;
24 | }
25 | 
26 | fn velocity_system(time: Res<Time>, mut position: Mut<Translation>, velocity: Mut<Velocity>) {
27 |     let y = position.0.y();
28 |     let x = position.0.x();
29 |     let delta = time.delta_seconds;
30 |     position.0.set_y(y + velocity.0.y() * delta);
31 |     position.0.set_x(x + velocity.0.x() * delta);
32 | }
33 | 


--------------------------------------------------------------------------------
/src/bounds_deletion.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | pub struct OffsceenDeletion;
 4 | 
 5 | pub struct BoundsDeletionPlugin;
 6 | 
 7 | impl Plugin for BoundsDeletionPlugin {
 8 |     fn build(&self, app: &mut AppBuilder) {
 9 |         app.add_system(offscreen_remove_system.system());
10 |     }
11 | }
12 | 
13 | fn offscreen_remove_system(
14 |     mut commands: Commands,
15 |     mut worlds: Query<&mut World>,
16 |     mut pipe_query: Query<(Entity, &mut Translation, &OffsceenDeletion)>,
17 | ) {
18 |     let padding = 300.0;
19 |     for (entity, translation, _od) in &mut pipe_query.iter() {
20 |         // Left side of screen
21 |         if translation.0.x() < -1920.0 * 0.5 - padding {
22 |             for world in &mut worlds.iter() {
23 |                 // Due to despawning of entity from other systems, avoid despawn panic
24 |                 if !world.contains(entity) {
25 |                     commands.despawn(entity);
26 |                 }
27 |             }
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/screens.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | 
 3 | pub struct StartScreen;
 4 | pub struct EndScreen;
 5 | 
 6 | pub struct ScreensPlugin;
 7 | 
 8 | impl Plugin for ScreensPlugin {
 9 |     fn build(&self, app: &mut AppBuilder) {
10 |         app.add_startup_system(setup.system());
11 |     }
12 | }
13 | 
14 | fn setup(
15 |     mut commands: Commands,
16 |     asset_server: Res<AssetServer>,
17 |     mut materials: ResMut<Assets<ColorMaterial>>,
18 | ) {
19 |     let start_texture_handle = asset_server.load("assets/SpaceToStart.png").unwrap();
20 |     let game_over_texture_handle = asset_server.load("assets/GameOverText.png").unwrap();
21 |     commands
22 |         // Start Screen
23 |         .spawn(SpriteComponents {
24 |             material: materials.add(start_texture_handle.into()),
25 |             ..Default::default()
26 |         })
27 |         .with(StartScreen)
28 |         .spawn(SpriteComponents {
29 |             material: materials.add(game_over_texture_handle.into()),
30 |             draw: Draw {
31 |                 is_transparent: true,
32 |                 is_visible: false,
33 |                 render_commands: Vec::new(),
34 |             },
35 |             ..Default::default()
36 |         })
37 |         .with(EndScreen);
38 | }
39 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | mod animation;
 3 | mod bird;
 4 | mod bounds_deletion;
 5 | mod clouds;
 6 | mod gamedata;
 7 | mod gamestate;
 8 | mod mountains;
 9 | mod physics;
10 | mod pipes;
11 | mod screens;
12 | 
13 | use animation::*;
14 | use bird::*;
15 | use clouds::*;
16 | use gamedata::*;
17 | use gamestate::*;
18 | use mountains::*;
19 | use physics::*;
20 | use pipes::*;
21 | use screens::*;
22 | 
23 | fn main() {
24 |     App::build()
25 |         .add_default_plugins()
26 |         .add_plugin(PipePlugin)
27 |         .add_plugin(BirdPlugin)
28 |         .add_plugin(CloudPlugin)
29 |         .add_plugin(MountainPlugin)
30 |         .add_plugin(AnimationPlugin)
31 |         .add_plugin(PhysicsPlugin)
32 |         .add_plugin(ScreensPlugin)
33 |         .add_plugin(GameStatePlugin)
34 |         .add_startup_system(setup.system())
35 |         .add_resource(ClearColor(Color::rgb(0.34, 0.75, 0.79)))
36 |         .add_resource(JumpHeight(23.0 * 40.0))
37 |         .add_resource(Gravity(45.0 * 40.0))
38 |         .add_resource(GameData {
39 |             game_state: GameState::Menu,
40 |             score: 0,
41 |         })
42 |         .run();
43 | }
44 | 
45 | fn setup(
46 |     mut commands: Commands,
47 |     mut asset_server: Res<AssetServer>,
48 |     mut textures: ResMut<Assets<Texture>>,
49 |     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
50 | ) {
51 |     commands.spawn(Camera2dComponents::default());
52 |     bird::spawn_bird(
53 |         &mut commands,
54 |         &mut asset_server,
55 |         &mut textures,
56 |         &mut texture_atlases,
57 |     );
58 | }
59 | 


--------------------------------------------------------------------------------
/src/clouds.rs:
--------------------------------------------------------------------------------
 1 | use crate::physics;
 2 | use bevy::prelude::*;
 3 | use physics::*;
 4 | use rand::{thread_rng, Rng};
 5 | 
 6 | pub struct CloudTimer(Timer);
 7 | 
 8 | pub struct CloudPlugin;
 9 | 
10 | impl Plugin for CloudPlugin {
11 |     fn build(&self, app: &mut AppBuilder) {
12 |         app.add_system(cloud_spawn_system.system())
13 |             .add_resource(CloudTimer(Timer::from_seconds(1.0, true)));
14 |     }
15 | }
16 | 
17 | fn cloud_spawn_system(
18 |     mut commands: Commands,
19 |     time: Res<Time>,
20 |     mut cloud_timer: ResMut<CloudTimer>,
21 |     asset_server: Res<AssetServer>,
22 |     mut materials: ResMut<Assets<ColorMaterial>>,
23 | ) {
24 |     let mut rng = thread_rng();
25 |     let cloud_texture = match rng.gen_bool(0.5) {
26 |         true => asset_server.load("assets/cloud_1.png").unwrap(),
27 |         false => asset_server.load("assets/cloud_2.png").unwrap(),
28 |     };
29 | 
30 |     cloud_timer.0.tick(time.delta_seconds);
31 |     if cloud_timer.0.finished {
32 |         commands
33 |             .spawn(SpriteComponents {
34 |                 material: materials.add(cloud_texture.into()),
35 |                 scale: Scale(rng.gen_range(6.0, 30.0)),
36 |                 translation: Translation(Vec3::new(
37 |                     1920.0 * 0.5 + 30.0 * 43.0,
38 |                     rng.gen_range(-1280.0 * 0.5, 1280.0 * 0.5),
39 |                     2.0,
40 |                 )),
41 |                 ..Default::default()
42 |             })
43 |             .with(Velocity(Vec2::new(
44 |                 rng.gen_range(-700.0, -400.0),
45 |                 rng.gen_range(-10.0, 10.0),
46 |             )));
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/animation.rs:
--------------------------------------------------------------------------------
 1 | use bevy::prelude::*;
 2 | pub struct AnimationPlugin;
 3 | 
 4 | pub struct AnimationFrame {
 5 |     pub index: i32,
 6 |     pub time: f32,
 7 | }
 8 | 
 9 | pub struct Animation {
10 |     pub frames: Vec<AnimationFrame>,
11 |     pub current_frame: i32,
12 | }
13 | 
14 | pub struct Animations {
15 |     pub animations: Vec<Animation>,
16 |     pub current_animation: i32,
17 | }
18 | 
19 | impl Plugin for AnimationPlugin {
20 |     fn build(&self, app: &mut AppBuilder) {
21 |         app.add_system(animate_system.system());
22 |     }
23 | }
24 | 
25 | fn animate_system(
26 |     mut query: Query<(
27 |         &mut Timer,
28 |         &mut TextureAtlasSprite,
29 |         &mut Animations,
30 |     )>,
31 | ) {
32 |     for (mut timer, mut sprite, mut animations) in &mut query.iter() {
33 |         if timer.finished {
34 |             let current_animation_index = animations.current_animation;
35 |             match animations
36 |                 .animations
37 |                 .get_mut(current_animation_index as usize)
38 |             {
39 |                 Some(animation) => {
40 |                     animation.current_frame += 1;
41 |                     if animation.current_frame as usize >= animation.frames.len() {
42 |                         animation.current_frame = 0;
43 |                     }
44 |                     let frame_data = animation
45 |                         .frames
46 |                         .get(animation.current_frame as usize)
47 |                         .unwrap();
48 |                     timer.duration = frame_data.time;
49 |                     if let Some(frame) = animation.frames.get(animation.current_frame as usize) {
50 |                         sprite.index = frame.index as u32;
51 |                     }
52 |                 }
53 |                 None => {}
54 |             }
55 |         }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/gamestate.rs:
--------------------------------------------------------------------------------
 1 | use crate::bird;
 2 | use crate::gamedata;
 3 | use crate::physics;
 4 | use crate::screens;
 5 | use bevy::prelude::*;
 6 | 
 7 | use bird::*;
 8 | use gamedata::*;
 9 | use physics::*;
10 | use screens::*;
11 | 
12 | #[derive(std::cmp::PartialEq)]
13 | pub enum GameState {
14 |     Menu,
15 |     Playing,
16 |     Dead,
17 | }
18 | 
19 | pub struct GameStatePlugin;
20 | 
21 | impl Plugin for GameStatePlugin {
22 |     fn build(&self, app: &mut AppBuilder) {
23 |         app.add_system(handle_gamestate_system.system());
24 |     }
25 | }
26 | 
27 | fn handle_gamestate_system(
28 |     mut game_data: ResMut<GameData>,
29 |     keyboard_input: Res<Input<KeyCode>>,
30 |     mut player_query: Query<(&Player, &mut Translation, &mut Velocity)>,
31 |     mut end_screen_query: Query<(&EndScreen, &mut Draw)>,
32 |     mut start_screen_query: Query<(&StartScreen, &mut Draw)>,
33 | ) {
34 |     match game_data.game_state {
35 |         GameState::Menu => {
36 |             if keyboard_input.just_pressed(KeyCode::Space) {
37 |                 game_data.game_state = GameState::Playing;
38 |                 for (_ss, mut draw) in &mut start_screen_query.iter() {
39 |                     draw.is_visible = false;
40 |                 }
41 |             }
42 |         }
43 |         GameState::Playing => {}
44 |         GameState::Dead => {
45 |             if keyboard_input.just_pressed(KeyCode::Space) {
46 |                 game_data.game_state = GameState::Playing;
47 |                 for (_p, mut translation, mut velocity) in &mut player_query.iter() {
48 |                     translation.0 = Vec3::new(0.0, 0.0, 100.0);
49 |                     velocity.0.set_y(0.0);
50 |                 }
51 |                 for (_es, mut draw) in &mut end_screen_query.iter() {
52 |                     draw.is_visible = false;
53 |                 }
54 |             }
55 |         }
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/mountains.rs:
--------------------------------------------------------------------------------
 1 | use crate::bounds_deletion;
 2 | use crate::physics;
 3 | use bevy::prelude::*;
 4 | use bounds_deletion::*;
 5 | use physics::*;
 6 | use rand::{thread_rng, Rng};
 7 | 
 8 | // Spawn mountains with a delay
 9 | pub struct MountainTimer(pub Timer);
10 | 
11 | pub struct MountainPlugin;
12 | 
13 | impl Plugin for MountainPlugin {
14 |     fn build(&self, app: &mut AppBuilder) {
15 |         app.add_system(mountain_spawn_system.system())
16 |             .add_resource(MountainTimer(Timer::from_seconds(3.0, true)));
17 |     }
18 | }
19 | 
20 | fn mountain_spawn_system(
21 |     mut commands: Commands,
22 |     time: Res<Time>,
23 |     mut mountain_timer: ResMut<MountainTimer>,
24 |     asset_server: Res<AssetServer>,
25 |     mut materials: ResMut<Assets<ColorMaterial>>,
26 | ) {
27 |     let mut rng = thread_rng();
28 |     let mountain_texture = match rng.gen_bool(0.5) {
29 |         true => asset_server.load("assets/mountain.png").unwrap(),
30 |         false => asset_server.load("assets/mountain.png").unwrap(),
31 |     };
32 | 
33 |     mountain_timer.0.tick(time.delta_seconds);
34 |     if mountain_timer.0.finished {
35 |         commands
36 |             .spawn(SpriteComponents {
37 |                 scale: Scale(3.0),
38 |                 material: materials.add(ColorMaterial::modulated_texture(
39 |                     mountain_texture,
40 |                     Color::rgb(0.36, 0.36, 0.36),
41 |                 )),
42 |                 translation: Translation(Vec3::new(1920.0 * 0.5 + 30.0 * 43.0, -1280.0 * 0.5, 0.2)),
43 |                 ..Default::default()
44 |             })
45 |             .with(OffsceenDeletion)
46 |             .with(Velocity(Vec2::new(-200.0, 0.0)));
47 |         commands
48 |             .spawn(SpriteComponents {
49 |                 scale: Scale(3.0),
50 |                 translation: Translation(Vec3::new(
51 |                     1920.0 * 0.5 + 30.0 * 43.0,
52 |                     -1280.0 * 0.5 - 100.0,
53 |                     0.3,
54 |                 )),
55 |                 material: materials.add(ColorMaterial::modulated_texture(
56 |                     mountain_texture,
57 |                     Color::rgb(0.26, 0.26, 0.26),
58 |                 )),
59 |                 ..Default::default()
60 |             })
61 |             .with(OffsceenDeletion)
62 |             .with(Velocity(Vec2::new(-400.0, 0.0)));
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/pipes.rs:
--------------------------------------------------------------------------------
  1 | use crate::bounds_deletion;
  2 | use crate::gamedata;
  3 | use crate::gamestate;
  4 | use crate::physics;
  5 | use bevy::prelude::*;
  6 | use bounds_deletion::*;
  7 | use gamedata::*;
  8 | use gamestate::*;
  9 | use physics::*;
 10 | use rand::{thread_rng, Rng};
 11 | 
 12 | pub struct Pipe;
 13 | 
 14 | pub struct SpawnTimer {
 15 |     pub timer: Timer,
 16 |     // center pos of pipes, in precentage
 17 |     pub last_pos: f32,
 18 | }
 19 | 
 20 | pub struct PipeSpawnSettings {
 21 |     pub min_time: f32,
 22 |     pub max_time: f32,
 23 |     pub speed: f32,
 24 |     // distance from upper and lower pipe, in precentage
 25 |     pub min_pipe_distance: f32,
 26 |     pub max_pipe_distance: f32,
 27 |     pub max_center_delta: f32,
 28 | }
 29 | 
 30 | #[derive(PartialEq)]
 31 | pub enum Collider {
 32 |     Solid,
 33 |     ScoreGiver,
 34 | }
 35 | 
 36 | pub struct PipePlugin;
 37 | 
 38 | impl Plugin for PipePlugin {
 39 |     fn build(&self, app: &mut AppBuilder) {
 40 |         app.add_system(spawn_pipe_system.system())
 41 |             .add_resource(SpawnTimer {
 42 |                 timer: Timer::from_seconds(2.0, true),
 43 |                 last_pos: 0.5,
 44 |             })
 45 |             .add_resource(PipeSpawnSettings {
 46 |                 min_time: 0.9,
 47 |                 max_time: 1.2,
 48 |                 speed: -700.0,
 49 |                 min_pipe_distance: 300.0,
 50 |                 max_pipe_distance: 600.0,
 51 |                 max_center_delta: 0.4,
 52 |             });
 53 |     }
 54 | }
 55 | 
 56 | fn spawn_pipe_system(
 57 |     mut commands: Commands,
 58 |     pipe_settings: Res<PipeSpawnSettings>,
 59 |     game_data: Res<GameData>,
 60 |     asset_server: Res<AssetServer>,
 61 |     time: Res<Time>,
 62 |     mut spawn_timer: ResMut<SpawnTimer>,
 63 |     mut materials: ResMut<Assets<ColorMaterial>>,
 64 |     mut textures: ResMut<Assets<Texture>>,
 65 | ) {
 66 |     if game_data.game_state != GameState::Playing {
 67 |         return;
 68 |     }
 69 | 
 70 |     spawn_timer.timer.tick(time.delta_seconds);
 71 |     if !spawn_timer.timer.finished {
 72 |         return;
 73 |     }
 74 | 
 75 |     let mut rng = thread_rng();
 76 |     spawn_timer.timer.duration = rng.gen_range(pipe_settings.min_time, pipe_settings.max_time);
 77 | 
 78 |     let mut new_center_pos = spawn_timer.last_pos
 79 |         - rng.gen_range(
 80 |             -pipe_settings.max_center_delta,
 81 |             pipe_settings.max_center_delta,
 82 |         );
 83 | 
 84 |     // sorry for the hardcoded values
 85 |     // This is the extent from the center in Y, a pipe can go maximum, until it flies in the air
 86 |     let clamp_range = (1280.0 - (6.0 * 128.0)) / 1280.0;
 87 | 
 88 |     // Clamp func seem to be nightly only for now
 89 |     new_center_pos = new_center_pos.min(clamp_range);
 90 |     new_center_pos = new_center_pos.max(-clamp_range);
 91 |     spawn_timer.last_pos = new_center_pos;
 92 |     // to world units
 93 |     new_center_pos *= 1280.0 * 0.5;
 94 | 
 95 |     let pipe_texture_handle = asset_server
 96 |         .load_sync(&mut textures, "assets/pipe.png")
 97 |         .unwrap();
 98 | 
 99 |     let pipe_offset_y = (6.0 * 128.0) * 0.5;
100 |     let pipe_offset_x = (6.0 * 32.0) * 0.5;
101 |     let mut pipe_delta = rng.gen_range(
102 |         pipe_settings.min_pipe_distance,
103 |         pipe_settings.max_pipe_distance,
104 |     );
105 |     // half the size because both pipes will be offseted in opposide direction
106 |     pipe_delta *= 0.5;
107 |     let x_pos = 1920.0 * 0.5 + pipe_offset_x;
108 | 
109 |     // lower pipe
110 |     commands
111 |         .spawn(SpriteComponents {
112 |             material: materials.add(pipe_texture_handle.into()),
113 |             scale: Scale(6.0),
114 |             draw: Draw {
115 |                 is_transparent: true,
116 |                 is_visible: true,
117 |                 render_commands: Vec::new(),
118 |             },
119 |             translation: Translation::new(x_pos, -pipe_offset_y + new_center_pos - pipe_delta, 3.0),
120 |             ..Default::default()
121 |         })
122 |         .with(Velocity(Vec2::new(pipe_settings.speed, 0.0)))
123 |         .with(Pipe)
124 |         .with(OffsceenDeletion)
125 |         .with(Collider::Solid);
126 |     // higher pipe
127 |     commands
128 |         .spawn(SpriteComponents {
129 |             material: materials.add(pipe_texture_handle.into()),
130 |             scale: Scale(6.0),
131 |             draw: Draw {
132 |                 is_transparent: true,
133 |                 is_visible: true,
134 |                 render_commands: Vec::new(),
135 |             },
136 |             translation: Translation::new(x_pos, pipe_offset_y + new_center_pos + pipe_delta, 3.0),
137 |             rotation: Rotation::from_rotation_z(std::f32::consts::PI),
138 |             ..Default::default()
139 |         })
140 |         .with(Pipe)
141 |         .with(OffsceenDeletion)
142 |         .with(Velocity(Vec2::new(pipe_settings.speed, 0.0)))
143 |         .with(Collider::Solid);
144 | 
145 |     // score collider offseted by half player size
146 |     let score_offset = Vec3::new(32.0 * 6.0 * 0.5, 0.0, 0.0);
147 |     commands
148 |         .spawn((
149 |             Translation(score_offset + Vec3::new(x_pos, 0.0, 0.0)),
150 |             Collider::ScoreGiver,
151 |             Velocity(Vec2::new(pipe_settings.speed, 0.0)),
152 |         ))
153 |         .with(OffsceenDeletion);
154 | }
155 | 


--------------------------------------------------------------------------------
/src/bird.rs:
--------------------------------------------------------------------------------
  1 | use bevy::{
  2 |     input::{keyboard::KeyCode, Input},
  3 |     prelude::*,
  4 |     sprite::collide_aabb::{collide},
  5 | };
  6 | 
  7 | use crate::animation;
  8 | use crate::gamedata;
  9 | use crate::gamestate;
 10 | use crate::physics;
 11 | use crate::pipes;
 12 | use crate::screens;
 13 | 
 14 | use animation::*;
 15 | use gamedata::*;
 16 | use gamestate::*;
 17 | use physics::*;
 18 | use pipes::*;
 19 | use screens::*;
 20 | 
 21 | pub struct Player;
 22 | pub struct JumpHeight(pub f32);
 23 | 
 24 | // data for animating rotation
 25 | pub struct VelocityRotator {
 26 |     pub angle_up: f32,
 27 |     pub angle_down: f32,
 28 |     // The amount of velocity to reach the min or max angle
 29 |     pub velocity_max: f32,
 30 | }
 31 | 
 32 | pub struct BirdPlugin;
 33 | 
 34 | impl Plugin for BirdPlugin {
 35 |     fn build(&self, app: &mut AppBuilder) {
 36 |         app.add_system(player_input.system())
 37 |             .add_system(player_bounds_system.system())
 38 |             .add_system(player_collision_system.system())
 39 |             .add_system(velocity_rotator_system.system())
 40 |             .add_system(velocity_animator_system.system());
 41 |     }
 42 | }
 43 | 
 44 | fn player_input(
 45 |     game_data: Res<GameData>,
 46 |     jump_height: Res<JumpHeight>,
 47 |     keyboard_input: Res<Input<KeyCode>>,
 48 |     _player: Mut<Player>,
 49 |     translation: Mut<Translation>,
 50 |     velocity: Mut<Velocity>,
 51 | ) {
 52 |     match game_data.game_state {
 53 |         GameState::Menu => {
 54 |             handle_stay_in_screen(jump_height, velocity, translation);
 55 |         }
 56 |         GameState::Playing => {
 57 |             handle_jump(keyboard_input, jump_height, velocity);
 58 |         }
 59 |         GameState::Dead => {}
 60 |     }
 61 | }
 62 | 
 63 | // Auto jump until input is given
 64 | fn handle_stay_in_screen(
 65 |     jump_height: Res<JumpHeight>,
 66 |     mut velocity: Mut<Velocity>,
 67 |     translation: Mut<Translation>,
 68 | ) {
 69 |     if translation.0.y() < 0.0 {
 70 |         velocity.0.set_y(jump_height.0);
 71 |     }
 72 | }
 73 | 
 74 | fn handle_jump(
 75 |     keyboard_input: Res<Input<KeyCode>>,
 76 |     jump_height: Res<JumpHeight>,
 77 |     mut velocity: Mut<Velocity>,
 78 | ) {
 79 |     if keyboard_input.just_pressed(KeyCode::Space) {
 80 |         velocity.0.set_y(jump_height.0);
 81 |     }
 82 | }
 83 | 
 84 | fn player_bounds_system(
 85 |     mut commands: Commands,
 86 |     mut game_data: ResMut<GameData>,
 87 |     mut player_query: Query<(&Player, &mut Translation, &mut Velocity)>,
 88 |     mut pipe_query: Query<(&Pipe, &Translation, &Collider, &Sprite, Entity)>,
 89 |     mut score_collider_query: Query<(&Translation, &Collider, Entity)>,
 90 |     mut end_screen_query: Query<(&EndScreen, &mut Draw)>,
 91 | ) {
 92 |     let half_screen_size = 1280.0 * 0.5;
 93 |     let player_size = 32.0 * 6.0;
 94 |     for (_p, mut translation, mut velocity) in &mut player_query.iter() {
 95 |         // bounce against ceiling
 96 |         if translation.0.y() > half_screen_size - player_size {
 97 |             velocity.0.set_y(-3.0);
 98 |             translation.0.set_y(half_screen_size - player_size);
 99 |         }
100 |         // death on bottom touch
101 |         if translation.0.y() < -half_screen_size {
102 |             trigger_death(
103 |                 &mut commands,
104 |                 &mut game_data,
105 |                 &mut pipe_query,
106 |                 &mut score_collider_query,
107 |                 &mut end_screen_query,
108 |             );
109 |         }
110 |     }
111 | }
112 | 
113 | fn player_collision_system(
114 |     mut commands: Commands,
115 |     mut game_data: ResMut<GameData>,
116 |     mut worlds: Query<&mut World>,
117 |     mut player_query: Query<(&Player, &Translation)>,
118 |     mut pipe_query: Query<(&Pipe, &Translation, &Collider, &Sprite, Entity)>,
119 |     mut score_collider_query: Query<(&Translation, &Collider, Entity)>,
120 |     mut end_screen_query: Query<(&EndScreen, &mut Draw)>,
121 | ) {
122 |     // Player size can't be fetched from AtlasTextureSprite, so I'm hard coding it here...
123 |     let mut player_size = 6.0 * 32.0;
124 |     // Make player hitbox half size, to feel more fair
125 |     player_size *= 0.4;
126 |     let player_size_vec = (player_size, player_size);
127 |     for (_player, player_translation) in &mut player_query.iter() {
128 |         for (translation, collider, entity) in &mut score_collider_query.iter() {
129 |             if *collider != Collider::ScoreGiver {
130 |                 continue;
131 |             }
132 |             let collision = collide(
133 |                 player_translation.0,
134 |                 player_size_vec.into(),
135 |                 translation.0,
136 |                 Vec2::new(10.0, 1280.0),
137 |             );
138 |             if collision.is_some() {
139 |                 game_data.score += 1;
140 |                 println!("got score!: {}", game_data.score);
141 |                 // Remove coin collider, quick simple solution
142 |                 for world in &mut worlds.iter() {
143 |                     if !world.contains(entity) {
144 |                         commands.despawn(entity);
145 |                     }
146 |                 }
147 |             }
148 |         }
149 |         // Check for collision
150 |         let mut did_collide = false;
151 |         for (_pipe, pipe_translation, _collider, pipe_sprite, _pipe_entity) in
152 |             &mut pipe_query.iter()
153 |         {
154 |             let collision = collide(
155 |                 player_translation.0,
156 |                 player_size_vec.into(),
157 |                 pipe_translation.0,
158 |                 pipe_sprite.size * 6.0,
159 |             );
160 |             if collision.is_some() {
161 |                 did_collide = true;
162 |                 break;
163 |             }
164 |         }
165 |         if did_collide {
166 |             trigger_death(
167 |                 &mut commands,
168 |                 &mut game_data,
169 |                 &mut pipe_query,
170 |                 &mut score_collider_query,
171 |                 &mut end_screen_query,
172 |             );
173 |         }
174 |     }
175 | }
176 | 
177 | fn trigger_death(
178 |     commands: &mut Commands,
179 |     game_data: &mut ResMut<GameData>,
180 |     pipe_query: &mut Query<(&Pipe, &Translation, &Collider, &Sprite, Entity)>,
181 |     score_query: &mut Query<(&Translation, &Collider, Entity)>,
182 |     end_screen_query: &mut Query<(&EndScreen, &mut Draw)>,
183 | ) {
184 |     game_data.game_state = GameState::Dead;
185 |     game_data.score = 0;
186 |     // Despawn all pipes
187 |     for (_p, _pt, _c, _ps, pipe_entity) in &mut pipe_query.iter() {
188 |         commands.despawn(pipe_entity);
189 |     }
190 |     // Despawn score colliders
191 |     for (_t, collider, score_entity) in &mut score_query.iter() {
192 |         if *collider == Collider::ScoreGiver {
193 |             commands.despawn(score_entity);
194 |         }
195 |     }
196 |     for (_es, mut draw) in &mut end_screen_query.iter() {
197 |         draw.is_visible = true;
198 |     }
199 | }
200 | 
201 | fn velocity_rotator_system(
202 |     velocity: Mut<Velocity>,
203 |     mut rotation: Mut<Rotation>,
204 |     velocity_rotator: Mut<VelocityRotator>,
205 | ) {
206 |     //let quat = Quat::from_rotation_z(velocity_rotator.).lerp();
207 |     let mut procentage = velocity.0.y() / velocity_rotator.velocity_max;
208 |     procentage = procentage.max(-1.0);
209 |     procentage = procentage.min(1.0);
210 |     // convert from -1 -> 1 to: 0 -> 1
211 |     procentage = (procentage + 1.0) * 0.5;
212 | 
213 |     // Lerp from lower angle to upper angle
214 |     let rad_angle =
215 |         (1.0 - procentage) * velocity_rotator.angle_down + procentage * velocity_rotator.angle_up;
216 | 
217 |     rotation.0 = Quat::from_rotation_z(rad_angle);
218 | }
219 | 
220 | fn velocity_animator_system(mut query: Query<(&mut Animations, &Velocity)>) {
221 |     for (mut animations, velocity) in &mut query.iter() {
222 |         if velocity.0.y() > 0.0 {
223 |             animations.current_animation = 0;
224 |         } else {
225 |             animations.current_animation = 1;
226 |         }
227 |     }
228 | }
229 | 
230 | pub fn spawn_bird(
231 |     commands: &mut Commands,
232 |     asset_server: &mut Res<AssetServer>,
233 |     mut textures: &mut ResMut<Assets<Texture>>,
234 |     texture_atlases: &mut ResMut<Assets<TextureAtlas>>,
235 | ) {
236 |     let texture_handle = asset_server
237 |         .load_sync(&mut textures, "assets/bird.png")
238 |         .unwrap();
239 | 
240 |     let texture = textures.get(&texture_handle).unwrap();
241 |     let texture_atlas = TextureAtlas::from_grid(texture_handle, texture.size, 2, 2);
242 |     let texture_atlas_handle = texture_atlases.add(texture_atlas);
243 | 
244 |     commands
245 |         .spawn(SpriteSheetComponents {
246 |             texture_atlas: texture_atlas_handle,
247 |             scale: Scale(6.0),
248 |             translation: Translation::new(0.0, 0.0, 100.0),
249 |             draw: Draw {
250 |                 is_transparent: true,
251 |                 is_visible: true,
252 |                 render_commands: Vec::new(),
253 |             },
254 |             ..Default::default()
255 |         })
256 |         .with(Timer::from_seconds(0.1, true))
257 |         .with(Player)
258 |         .with(AffectedByGravity)
259 |         .with(VelocityRotator {
260 |             angle_up: std::f32::consts::PI * 0.5 * 0.7,
261 |             angle_down: -std::f32::consts::PI * 0.5 * 0.5,
262 |             velocity_max: 400.0,
263 |         })
264 |         .with(Velocity(Vec2::zero()))
265 |         .with(Animations {
266 |             animations: vec![
267 |                 Animation {
268 |                     current_frame: 0,
269 |                     frames: vec![
270 |                         AnimationFrame {
271 |                             index: 0,
272 |                             time: 0.1,
273 |                         },
274 |                         AnimationFrame {
275 |                             index: 1,
276 |                             time: 0.1,
277 |                         },
278 |                         AnimationFrame {
279 |                             index: 2,
280 |                             time: 0.3,
281 |                         },
282 |                         AnimationFrame {
283 |                             index: 1,
284 |                             time: 0.1,
285 |                         },
286 |                     ],
287 |                 },
288 |                 Animation {
289 |                     current_frame: 0,
290 |                     frames: vec![AnimationFrame {
291 |                         index: 3,
292 |                         time: 0.2,
293 |                     }],
294 |                 },
295 |             ],
296 |             current_animation: 0,
297 |         });
298 | }
299 | 


--------------------------------------------------------------------------------