一个简单的 rust 项目 使用 bevy 引擎 复刻 Flappy Bird 小游戏 ...

锦通  金牌会员 | 2023-4-24 17:12:56 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 927|帖子 927|积分 2781

Rust + Bevy 实现的 Flappy Bird 游戏

简介

一个使用 bevy 引擎复刻的 Flappy Bird 经典小游戏。
通过该项目我们可以学到：bevy 的自定义组件，自定义插件，自定义资源，sprite 的旋转，sprite 的移动，sprite sheet 动画的定义使用，状态管理，等内容…
简单介绍一下包含的内容：

  • 游戏状态管理 Menu、InGame、Paused、GameOver。
  • 小鸟碰撞检测。
  • 地面移动。
  • 小鸟飞翔动画。
  • 小鸟飞行方向变化。
  • 小鸟重力系统。
  • 障碍物随机生成。
通过空格向上飞行。
按 P 暂停游戏，按 R 恢复游戏。
代码结构
  1. ·
  2. ├── assets/
  3. │   ├──audios/
  4. │   ├──fonts/
  5. │   └──images/
  6. ├── src/
  7. │   ├── components.rs
  8. │   ├── constants.rs
  9. │   ├── main.rs
  10. │   ├── obstacle.rs
  11. │   ├── player.rs
  12. │   ├── resource.rs
  13. │   └── state.rs
  14. ├── Cargo.lock
  15. └── Cargo.toml
复制代码

  • assets/audios 声音资源文件。
  • assets/fonts 字体资源文件。
  • assets/images 图片资源文件。
  • components.rs 游戏组件定义。
  • constants.rs 负责存储游戏中用到的常量。
  • main.rs 负责游戏的逻辑、插件交互、等内容。
  • obstacle.rs 障碍物生成、初始化。
  • player.rs 玩家角色插件，生成、移动、键盘处理的实现。
  • resource.rs 游戏资源定义。
  • state.rs 游戏状态管理。
components.rs
  1. use bevy::{
  2.     prelude::Component,
  3.     time::{Timer, TimerMode},
  4. };
  6. /// 玩家组件
  7. #[derive(Component)]
  8. pub struct Player;
  10. /// 玩家动画播放计时器
  11. #[derive(Component)]
  12. pub struct PlayerAnimationTimer(pub Timer);
  14. impl Default for PlayerAnimationTimer {
  15.     fn default() -> Self {
  16.         Self(Timer::from_seconds(0.1, TimerMode::Repeating))
  17.     }
  18. }
  20. /// 障碍物组件
  21. #[derive(Component)]
  22. pub struct Obstacle;
  24. /// 移动组件
  25. #[derive(Component)]
  26. pub struct Movable {
  27.     /// 移动时是否需要旋转
  28.     pub need_rotation: bool,
  29. }
  31. impl Default for Movable {
  32.     fn default() -> Self {
  33.         Self {
  34.             need_rotation: false,
  35.         }
  36.     }
  37. }
  39. /// 速度组件
  40. #[derive(Component)]
  41. pub struct Velocity {
  42.     pub x: f32,
  43.     pub y: f32,
  44. }
  46. impl Default for Velocity {
  47.     fn default() -> Self {
  48.         Self { x: 0., y: 0. }
  49.     }
  50. }
  52. /// 分数显示组件
  53. #[derive(Component)]
  54. pub struct DisplayScore;
  56. /// 菜单显示组件
  57. #[derive(Component)]
  58. pub struct DisplayMenu;
  60. /// 地面组件
  61. #[derive(Component)]
  62. pub struct Ground(pub f32);
  64. /// 游戏结束组件
  65. #[derive(Component)]
  66. pub struct DisplayGameOver;
复制代码
constants.rs
  1. /// 小鸟图片路径
  2. pub const BIRD_IMG_PATH: &str = "images/bird_columns.png";
  3. /// 小鸟图片大小
  4. pub const BIRD_IMG_SIZE: (f32, f32) = (34., 24.);
  5. /// 小鸟动画帧数
  6. pub const BIRD_ANIMATION_LEN: usize = 3;
  8. pub const WINDOW_WIDTH: f32 = 576.;
  9. pub const WINDOW_HEIGHT: f32 = 624.;
  11. /// 背景图片路径
  12. pub const BACKGROUND_IMG_PATH: &str = "images/background.png";
  13. /// 背景图片大小
  14. pub const BACKGROUND_IMG_SIZE: (f32, f32) = (288., 512.);
  15. /// 地面图片路径
  16. pub const GROUND_IMG_PATH: &str = "images/ground.png";
  17. /// 地面图片大小
  18. pub const GROUND_IMG_SIZE: (f32, f32) = (336., 112.);
  19. /// 一个单位地面的大小
  20. pub const GROUND_ITEM_SIZE: f32 = 48.;
  21. /// 管道图片路径
  22. pub const PIPE_IMG_PATH: &str = "images/pipe.png";
  23. /// 管道图片大小
  24. pub const PIPE_IMG_SIZE: (f32, f32) = (52., 320.);
  25. /// 飞翔声音路径
  26. pub const FLAY_AUDIO_PATH: &str = "audios/wing.ogg";
  27. /// 得分声音
  28. pub const POINT_AUDIO_PATH: &str = "audios/point.ogg";
  29. /// 死亡声音
  30. pub const DIE_AUDIO_PATH: &str = "audios/die.ogg";
  31. /// 被撞击声音
  32. pub const HIT_AUDIO_PATH: &str = "audios/hit.ogg";
  33. /// kenney future 字体路径
  34. pub const KENNEY_FUTURE_FONT_PATH: &str = "fonts/KenneyFuture.ttf";
  36. /// x 轴前进速度
  37. pub const SPAWN_OBSTACLE_TICK: f32 = 4.;
  38. /// x 轴前进速度
  39. pub const PLAYER_X_MAX_VELOCITY: f32 = 48.;
  40. /// y 轴最大上升速度
  41. pub const PLAYER_Y_MAX_UP_VELOCITY: f32 = 20.;
  42. /// y 轴每次上升像素
  43. pub const PLAYER_Y_UP_PIXEL: f32 = 10.;
  44. /// y 轴最大下落速度
  45. pub const PLAYER_Y_MAX_VELOCITY: f32 = 200.;
  46. /// y 轴下落加速度，每秒增加
  47. pub const GRAVITY_VELOCITY: f32 = 80.;
  48. /// 步长 (帧数)
  49. pub const TIME_STEP: f32 = 1. / 60.;
  51. /// 最大通过空间
  52. pub const GAP_MAX: f32 = 300.;
  53. /// 最小通过空间
  54. pub const GAP_MIN: f32 = 50.;
复制代码
main.rs
  1. use bevy::{
  2.     prelude::*,
  3.     sprite::collide_aabb::collide,
  4.     window::{Window, WindowPlugin, WindowPosition},
  5. };
  6. use obstacle::ObstaclePlugin;
  8. use components::{DisplayScore, Ground, Movable, Obstacle, Player, PlayerAnimationTimer, Velocity};
  9. use constants::*;
  10. use player::PlayerPlugin;
  11. use resource::{GameData, StaticAssets, WinSize};
  12. use state::{GameState, StatesPlugin};
  14. mod components;
  15. mod constants;
  16. mod obstacle;
  17. mod player;
  18. mod resource;
  19. mod state;
  21. fn main() {
  22.     App::new()
  23.         .add_state::<GameState>()
  24.         .insert_resource(ClearColor(Color::rgb_u8(205, 201, 201)))
  25.         .add_plugins(DefaultPlugins.set(WindowPlugin {
  26.             primary_window: Some(Window {
  27.                 title: "Flappy Bird".to_owned(),
  28.                 resolution: (WINDOW_WIDTH, WINDOW_HEIGHT).into(),
  29.                 position: WindowPosition::At(IVec2::new(2282, 0)),
  30.                 resizable: false,
  31.                 ..Default::default()
  32.             }),
  33.             ..Default::default()
  34.         }))
  35.         .add_system(system_startup.on_startup())
  36.         .add_plugin(StatesPlugin)
  37.         .add_plugin(PlayerPlugin)
  38.         .add_plugin(ObstaclePlugin)
  39.         .add_systems(
  40.             (
  41.                 score_display_update_system,
  42.                 player_animation_system,
  43.                 player_score_system,
  44.                 movable_system,
  45.                 ground_move_system,
  46.                 player_collision_check_system,
  47.             )
  48.                 .in_set(OnUpdate(GameState::InGame)),
  49.         )
  50.         .add_system(bevy::window::close_on_esc)
  51.         .run();
  52. }
  54. /// 玩家碰撞检测系统
  55. fn player_collision_check_system(
  56.     win_size: Res<WinSize>,
  57.     static_assets: Res<StaticAssets>,
  58.     audio_player: Res<Audio>,
  59.     mut next_state: ResMut<NextState<GameState>>,
  60.     obstacle_query: Query<(Entity, &Transform), With<Obstacle>>,
  61.     player_query: Query<(Entity, &Transform), With<Player>>,
  62. ) {
  63.     let player_result = player_query.get_single();
  64.     match player_result {
  65.         Ok((_, player_tf)) => {
  66.             let mut is_collision = false;
  67.             // 先进行边缘碰撞检测
  68.             if player_tf.translation.y >= win_size.height / 2.
  69.                 || player_tf.translation.y <= -(win_size.height / 2. - GROUND_IMG_SIZE.1)
  70.             {
  71.                 is_collision = true;
  72.             }
  74.             for (_, obstacle_tf) in obstacle_query.iter() {
  75.                 let collision = collide(
  76.                     player_tf.translation,
  77.                     Vec2 {
  78.                         x: BIRD_IMG_SIZE.0,
  79.                         y: BIRD_IMG_SIZE.1,
  80.                     },
  81.                     obstacle_tf.translation,
  82.                     Vec2 {
  83.                         x: PIPE_IMG_SIZE.0,
  84.                         y: PIPE_IMG_SIZE.1,
  85.                     },
  86.                 );
  87.                 if let Some(_) = collision {
  88.                     is_collision = true;
  89.                     break;
  90.                 }
  91.             }
  92.             // 判断是否已经发生碰撞
  93.             if is_collision {
  94.                 // 增加得分并播放声音
  95.                 audio_player.play(static_assets.hit_audio.clone());
  96.                 audio_player.play(static_assets.die_audio.clone());
  97.                 next_state.set(GameState::GameOver);
  98.             }
  99.         }
  100.         _ => (),
  101.     }
  102. }
  104. /// 玩家得分检测
  105. fn player_score_system(
  106.     mut commands: Commands,
  107.     mut game_data: ResMut<GameData>,
  108.     static_assets: Res<StaticAssets>,
  109.     audio_player: Res<Audio>,
  110.     obstacle_query: Query<(Entity, &Transform), With<Obstacle>>,
  111.     player_query: Query<(Entity, &Transform), With<Player>>,
  112. ) {
  113.     let player_result = player_query.get_single();
  114.     match player_result {
  115.         Ok((_, player_tf)) => {
  116.             let mut need_add_score = false;
  117.             for (entity, obstacle_tf) in obstacle_query.iter() {
  118.                 // 鸟的 尾巴通过管道的右边缘
  119.                 if player_tf.translation.x - BIRD_IMG_SIZE.0 / 2.
  120.                     > obstacle_tf.translation.x + PIPE_IMG_SIZE.0 / 2.
  121.                 {
  122.                     // 通过的话，将需要得分记为 true 并销毁管道
  123.                     need_add_score = true;
  124.                     commands.entity(entity).despawn();
  125.                 }
  126.             }
  127.             // 判断是否需要增加得分
  128.             if need_add_score {
  129.                 // 增加得分并播放声音
  130.                 game_data.add_score();
  131.                 audio_player.play(static_assets.point_audio.clone());
  132.                 game_data.call_obstacle_spawn();
  133.             }
  134.         }
  135.         _ => (),
  136.     }
  137. }
  139. /// 移动系统
  140. ///
  141. /// * 不考虑正负值，只做加法，需要具体的实体通过移动的方向自行考虑正负值
  142. fn movable_system(
  143.     mut query: Query<(&mut Transform, &Velocity, &Movable), (With<Movable>, With<Velocity>)>,
  144. ) {
  145.     for (mut transform, velocity, movable) in query.iter_mut() {
  146.         let x = velocity.x * TIME_STEP;
  147.         let y = velocity.y * TIME_STEP;
  148.         transform.translation.x += x;
  149.         transform.translation.y += y;
  150.         // 判断是否需要旋转
  151.         if movable.need_rotation {
  152.             if velocity.y > 0. {
  153.                 transform.rotation = Quat::from_rotation_z(velocity.y / PLAYER_Y_MAX_UP_VELOCITY);
  154.             } else {
  155.                 transform.rotation = Quat::from_rotation_z(velocity.y / PLAYER_Y_MAX_VELOCITY);
  156.             };
  157.         }
  158.     }
  159. }
  161. /// 地面移动组件
  162. fn ground_move_system(mut query: Query<(&mut Transform, &mut Ground)>) {
  163.     let result = query.get_single_mut();
  164.     match result {
  165.         Ok((mut transform, mut ground)) => {
  166.             ground.0 += 1.;
  167.             transform.translation.x = -ground.0;
  168.             ground.0 = ground.0 % GROUND_ITEM_SIZE;
  169.         }
  170.         _ => (),
  171.     }
  172. }
  174. /// 角色动画系统
  175. fn player_animation_system(
  176.     time: Res<Time>,
  177.     mut query: Query<(&mut PlayerAnimationTimer, &mut TextureAtlasSprite)>,
  178. ) {
  179.     for (mut timer, mut texture_atlas_sprite) in query.iter_mut() {
  180.         timer.0.tick(time.delta());
  181.         if timer.0.just_finished() {
  182.             let next_index = (texture_atlas_sprite.index + 1) % BIRD_ANIMATION_LEN;
  183.             texture_atlas_sprite.index = next_index;
  184.         }
  185.     }
  186. }
  188. /// 分数更新系统
  189. fn score_display_update_system(
  190.     game_data: Res<GameData>,
  191.     mut query: Query<&mut Text, With<DisplayScore>>,
  192. ) {
  193.     for mut text in &mut query {
  194.         text.sections[1].value = game_data.get_score().to_string();
  195.     }
  196. }
  198. fn system_startup(
  199.     mut commands: Commands,
  200.     asset_server: Res<AssetServer>,
  201.     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
  202.     windows: Query<&Window>,
  203. ) {
  204.     commands.spawn(Camera2dBundle::default());
  206.     let game_data = GameData::new();
  207.     commands.insert_resource(game_data);
  209.     let window = windows.single();
  210.     let (window_w, window_h) = (window.width(), window.height());
  211.     let win_size = WinSize {
  212.         width: window_w,
  213.         height: window_h,
  214.     };
  215.     commands.insert_resource(win_size);
  217.     let player_handle = asset_server.load(BIRD_IMG_PATH);
  219.     // 将 player_handle 加载的图片，用 BIRD_IMG_SIZE 的大小，按照 1 列，3 行，切图。
  220.     let texture_atlas =
  221.         TextureAtlas::from_grid(player_handle, Vec2::from(BIRD_IMG_SIZE), 1, 3, None, None);
  222.     let player = texture_atlases.add(texture_atlas);
  224.     let background = asset_server.load(BACKGROUND_IMG_PATH);
  225.     let pipe = asset_server.load(PIPE_IMG_PATH);
  226.     let ground = asset_server.load(GROUND_IMG_PATH);
  227.     let fly_audio = asset_server.load(FLAY_AUDIO_PATH);
  228.     let die_audio = asset_server.load(DIE_AUDIO_PATH);
  229.     let point_audio = asset_server.load(POINT_AUDIO_PATH);
  230.     let hit_audio = asset_server.load(HIT_AUDIO_PATH);
  231.     let kenney_future_font = asset_server.load(KENNEY_FUTURE_FONT_PATH);
  233.     let static_assets = StaticAssets {
  234.         player,
  235.         background,
  236.         pipe,
  237.         ground,
  238.         fly_audio,
  239.         die_audio,
  240.         point_audio,
  241.         hit_audio,
  242.         kenney_future_font,
  243.     };
  244.     commands.insert_resource(static_assets);
  246.     let (background_w, background_h) = BACKGROUND_IMG_SIZE;
  247.     let (ground_w, ground_h) = GROUND_IMG_SIZE;
  248.     commands.spawn(SpriteBundle {
  249.         texture: asset_server.load(BACKGROUND_IMG_PATH),
  250.         sprite: Sprite {
  251.             custom_size: Some(Vec2 {
  252.                 x: background_w * 2.,
  253.                 y: background_h,
  254.             }),
  255.             ..Default::default()
  256.         },
  257.         transform: Transform {
  258.             translation: Vec3 {
  259.                 x: 0.,
  260.                 y: ground_h / 2.,
  261.                 z: 1.,
  262.             },
  263.             ..Default::default()
  264.         },
  265.         ..Default::default()
  266.     });
  268.     commands.spawn((
  269.         SpriteBundle {
  270.             texture: asset_server.load(GROUND_IMG_PATH),
  271.             sprite: Sprite {
  272.                 custom_size: Some(Vec2 {
  273.                     x: ground_w * 2.,
  274.                     y: ground_h,
  275.                 }),
  276.                 ..Default::default()
  277.             },
  278.             transform: Transform {
  279.                 translation: Vec3 {
  280.                     x: 0.,
  281.                     y: window_h / 2. - background_h - ground_h / 2.,
  282.                     z: 4.,
  283.                 },
  284.                 ..Default::default()
  285.             },
  287.             ..Default::default()
  288.         },
  289.         Ground(GROUND_ITEM_SIZE),
  290.     ));
  291. }
复制代码
obstacle.rs
  1. use rand::{thread_rng, Rng};
  2. use std::time::Duration;
  4. use crate::{
  5.     components::{Movable, Obstacle, Velocity},
  6.     constants::{
  7.         BACKGROUND_IMG_SIZE, GAP_MAX, GAP_MIN, GROUND_IMG_SIZE, PIPE_IMG_SIZE,
  8.         PLAYER_X_MAX_VELOCITY, SPAWN_OBSTACLE_TICK,
  9.     },
  10.     resource::{GameData, StaticAssets, WinSize},
  11.     state::GameState,
  12. };
  14. use bevy::{
  15.     prelude::{
  16.         Commands, Entity, IntoSystemAppConfig, IntoSystemConfig, OnEnter, OnUpdate, Plugin, Query,
  17.         Res, ResMut, Transform, Vec3, With,
  18.     },
  19.     sprite::{Sprite, SpriteBundle},
  20.     time::common_conditions::on_timer,
  21. };
  23. /// 障碍物插件
  24. pub struct ObstaclePlugin;
  26. impl Plugin for ObstaclePlugin {
  27.     fn build(&self, app: &mut bevy::prelude::App) {
  28.         app.add_system(obstacle_init_system.in_schedule(OnEnter(GameState::InGame)))
  29.             .add_system(
  30.                 spawn_obstacle_system
  31.                     .run_if(on_timer(Duration::from_secs_f32(0.2)))
  32.                     .in_set(OnUpdate(GameState::InGame)),
  33.             );
  34.     }
  35. }
  37. /// 障碍物初始化
  38. fn obstacle_init_system(
  39.     mut commands: Commands,
  40.     static_assets: Res<StaticAssets>,
  41.     win_size: Res<WinSize>,
  42.     game_data: Res<GameData>,
  43.     query: Query<Entity, With<Obstacle>>,
  44. ) {
  45.     let count = query.iter().count();
  46.     if count >= 4 {
  47.         return;
  48.     }
  50.     let mut rng = thread_rng();
  51.     // 初始 x 坐标
  52.     let x = win_size.width / 2. + PIPE_IMG_SIZE.0 / 2.;
  53.     // 初始化 管道区域的中心点。因为要排除地面的高度
  54.     let center_y = (win_size.height - BACKGROUND_IMG_SIZE.1) / 2.;
  55.     // 定义合理范围
  56.     let reasonable_y_max = win_size.height / 2. - 100.;
  57.     let reasonable_y_min = -(win_size.height / 2. - 100. - GROUND_IMG_SIZE.1);
  59.     let size = SPAWN_OBSTACLE_TICK * PLAYER_X_MAX_VELOCITY;
  61.     for i in 0..2 {
  62.         let x = x - PIPE_IMG_SIZE.0 - size * i as f32;
  63.         // y轴 随机中心点
  64.         // 随机可通过区域的中心点
  65.         let point_y = rng.gen_range(reasonable_y_min..reasonable_y_max);
  66.         let half_distance = (center_y - point_y).abs() / 2.;
  68.         // 获取得分 ， 并根据得分获取一个随机的可通过区域的大小
  69.         let score = game_data.get_score();
  70.         let max = GAP_MAX - score as f32 / 10.;
  71.         // 不让 max 小于最小值
  72.         // 这里也可以做些其他的判断。改变下别的数据。比如说 让管道的移动速度变快！
  73.         let max = max.max(GAP_MIN);
  74.         let min = GAP_MIN;
  75.         let gap = rng.gen_range(min.min(max)..min.max(max));
  76.         let rand_half_gap = gap * rng.gen_range(0.3..0.7);
  77.         // 通过中心点，可通过区域，以及管道的高来计算 上下两个管道各自中心点的 y 坐标
  78.         let half_pipe = PIPE_IMG_SIZE.1 / 2.;
  79.         let pipe_upper = center_y + half_distance + (rand_half_gap + half_pipe);
  80.         let pipe_down = center_y - half_distance - (gap - rand_half_gap + half_pipe);
  82.         // 下方水管
  83.         commands.spawn((
  84.             SpriteBundle {
  85.                 texture: static_assets.pipe.clone(),
  86.                 transform: Transform {
  87.                     translation: Vec3 {
  88.                         x,
  89.                         y: pipe_down,
  90.                         z: 2.,
  91.                     },
  92.                     ..Default::default()
  93.                 },
  94.                 ..Default::default()
  95.             },
  96.             Velocity {
  97.                 x: -PLAYER_X_MAX_VELOCITY,
  98.                 y: 0.,
  99.             },
  100.             Movable {
  101.                 need_rotation: false,
  102.             },
  103.             Obstacle,
  104.         ));
  106.         // 上方水管
  107.         commands.spawn((
  108.             SpriteBundle {
  109.                 texture: static_assets.pipe.clone(),
  110.                 transform: Transform {
  111.                     translation: Vec3 {
  112.                         x,
  113.                         y: pipe_upper,
  114.                         z: 2.,
  115.                     },
  116.                     ..Default::default()
  117.                 },
  118.                 sprite: Sprite {
  119.                     flip_y: true,
  120.                     ..Default::default()
  121.                 },
  122.                 ..Default::default()
  123.             },
  124.             Velocity {
  125.                 x: -PLAYER_X_MAX_VELOCITY,
  126.                 y: 0.,
  127.             },
  128.             Movable {
  129.                 need_rotation: false,
  130.             },
  131.             Obstacle,
  132.         ));
  133.     }
  134. }
  136. fn spawn_obstacle_system(
  137.     mut commands: Commands,
  138.     mut game_data: ResMut<GameData>,
  139.     static_assets: Res<StaticAssets>,
  140.     win_size: Res<WinSize>,
  141. ) {
  142.     if !game_data.need_spawn_obstacle() {
  143.         return;
  144.     }
  145.     game_data.obstacle_call_back();
  146.     let mut rng = thread_rng();
  147.     // 初始 x 坐标
  148.     let x = win_size.width / 2. + PIPE_IMG_SIZE.0 / 2.;
  149.     // 初始化 管道区域的中心点。因为要排除地面的高度
  150.     let center_y = (win_size.height - BACKGROUND_IMG_SIZE.1) / 2.;
  152.     // y轴 随机中心点
  153.     // 定义合理范围
  154.     let reasonable_y_max = win_size.height / 2. - 100.;
  155.     let reasonable_y_min = -(win_size.height / 2. - 100. - GROUND_IMG_SIZE.1);
  156.     // 随机可通过区域的中心点
  157.     let point_y = rng.gen_range(reasonable_y_min..reasonable_y_max);
  158.     let half_distance = (center_y - point_y).abs() / 2.;
  160.     // 获取得分 ， 并根据得分获取一个随机的可通过区域的大小
  161.     let score = game_data.get_score();
  162.     let max = GAP_MAX - score as f32 / 10.;
  163.     // 不让 max 小于最小值
  164.     // 这里也可以做些其他的判断。改变下别的数据。比如说 让管道的移动速度变快！
  165.     let max = max.max(GAP_MIN);
  166.     let min = GAP_MIN;
  167.     let gap = rng.gen_range(min.min(max)..min.max(max));
  168.     let rand_half_gap = gap * rng.gen_range(0.3..0.7);
  169.     // 通过中心点，可通过区域，以及管道的高来计算 上下两个管道各自中心点的 y 坐标
  170.     let half_pipe = PIPE_IMG_SIZE.1 / 2.;
  171.     let pipe_upper = center_y + half_distance + (rand_half_gap + half_pipe);
  172.     let pipe_down = center_y - half_distance - (gap - rand_half_gap + half_pipe);
  174.     // 下方水管
  175.     commands.spawn((
  176.         SpriteBundle {
  177.             texture: static_assets.pipe.clone(),
  178.             transform: Transform {
  179.                 translation: Vec3 {
  180.                     x,
  181.                     y: pipe_down,
  182.                     z: 2.,
  183.                 },
  184.                 ..Default::default()
  185.             },
  186.             ..Default::default()
  187.         },
  188.         Velocity {
  189.             x: -PLAYER_X_MAX_VELOCITY,
  190.             y: 0.,
  191.         },
  192.         Movable {
  193.             need_rotation: false,
  194.         },
  195.         Obstacle,
  196.     ));
  198.     // 上方水管
  199.     commands.spawn((
  200.         SpriteBundle {
  201.             texture: static_assets.pipe.clone(),
  202.             transform: Transform {
  203.                 translation: Vec3 {
  204.                     x,
  205.                     y: pipe_upper,
  206.                     z: 2.,
  207.                 },
  208.                 ..Default::default()
  209.             },
  210.             sprite: Sprite {
  211.                 flip_y: true,
  212.                 ..Default::default()
  213.             },
  214.             ..Default::default()
  215.         },
  216.         Velocity {
  217.             x: -PLAYER_X_MAX_VELOCITY,
  218.             y: 0.,
  219.         },
  220.         Movable {
  221.             need_rotation: false,
  222.         },
  223.         Obstacle,
  224.     ));
  225. }
复制代码
player.rs
  1. use bevy::{
  2.     prelude::{
  3.         Audio, Commands, Input, IntoSystemAppConfig, IntoSystemConfigs, KeyCode, OnEnter, OnUpdate,
  4.         Plugin, Query, Res, ResMut, Transform, Vec3, With,
  5.     },
  6.     sprite::{SpriteSheetBundle, TextureAtlasSprite},
  7.     time::{Timer, TimerMode},
  8. };
  10. use crate::{
  11.     components::{Movable, Player, PlayerAnimationTimer, Velocity},
  12.     constants::{
  13.         GRAVITY_VELOCITY, PLAYER_Y_MAX_UP_VELOCITY, PLAYER_Y_MAX_VELOCITY, PLAYER_Y_UP_PIXEL,
  14.         TIME_STEP,
  15.     },
  16.     resource::{GameData, StaticAssets, WinSize},
  17.     state::GameState,
  18. };
  20. pub struct PlayerPlugin;
  22. impl Plugin for PlayerPlugin {
  23.     fn build(&self, app: &mut bevy::prelude::App) {
  24.         app.add_systems(
  25.             (input_key_system, bird_automatic_system).in_set(OnUpdate(GameState::InGame)),
  26.         )
  27.         .add_system(spawn_bird_system.in_schedule(OnEnter(GameState::InGame)));
  28.     }
  29. }
  31. /// 产生玩家
  32. fn spawn_bird_system(
  33.     mut commands: Commands,
  34.     win_size: Res<WinSize>,
  35.     static_assets: Res<StaticAssets>,
  36.     mut game_data: ResMut<GameData>,
  37. ) {
  38.     if !game_data.player_alive() {
  39.         let bird = static_assets.player.clone();
  40.         let (x, y) = (-win_size.width / 4. / 2., win_size.height / 2. / 3.);
  41.         commands.spawn((
  42.             SpriteSheetBundle {
  43.                 texture_atlas: bird,
  44.                 transform: Transform {
  45.                     translation: Vec3 { x, y, z: 2. },
  46.                     ..Default::default()
  47.                 },
  48.                 sprite: TextureAtlasSprite::new(0),
  49.                 ..Default::default()
  50.             },
  51.             Player,
  52.             Velocity { x: 0., y: 0. },
  53.             Movable {
  54.                 need_rotation: true,
  55.             },
  56.             PlayerAnimationTimer(Timer::from_seconds(0.2, TimerMode::Repeating)),
  57.         ));
  58.         game_data.alive();
  59.     }
  60. }
  62. /// 游戏中键盘事件系统
  63. fn input_key_system(
  64.     kb: Res<Input<KeyCode>>,
  65.     static_assets: Res<StaticAssets>,
  66.     audio_player: Res<Audio>,
  67.     mut query: Query<(&mut Velocity, &mut Transform), With<Player>>,
  68. ) {
  69.     if kb.just_released(KeyCode::Space) {
  70.         let vt = query.get_single_mut();
  71.         // 松开空格后，直接向上20像素，并且给一个向上的速度。
  72.         match vt {
  73.             Ok((mut velocity, mut transform)) => {
  74.                 transform.translation.y += PLAYER_Y_UP_PIXEL;
  75.                 velocity.y = PLAYER_Y_MAX_UP_VELOCITY;
  76.             }
  77.             _ => (),
  78.         }
  79.         audio_player.play(static_assets.fly_audio.clone());
  80.     }
  81. }
  83. /// 小鸟重力系统
  84. fn bird_automatic_system(mut query: Query<&mut Velocity, (With<Player>, With<Movable>)>) {
  85.     for mut velocity in query.iter_mut() {
  86.         velocity.y = velocity.y - GRAVITY_VELOCITY * TIME_STEP;
  87.         if velocity.y < -PLAYER_Y_MAX_VELOCITY {
  88.             velocity.y = -PLAYER_Y_MAX_VELOCITY;
  89.         }
  90.     }
  91. }
复制代码
resource.rs
  1. use bevy::{
  2.     prelude::{AudioSource, Handle, Image, Resource},
  3.     sprite::TextureAtlas,
  4.     text::Font,
  5. };
  7. /// 游戏数据资源
  8. #[derive(Resource)]
  9. pub struct GameData {
  10.     score: u8,
  11.     alive: bool,
  12.     need_add_obstacle: bool,
  13. }
  14. impl GameData {
  15.     pub fn new() -> Self {
  16.         Self {
  17.             score: 0,
  18.             alive: false,
  19.             need_add_obstacle: false,
  20.         }
  21.     }
  23.     pub fn need_spawn_obstacle(&self) -> bool {
  24.         self.need_add_obstacle
  25.     }
  27.     pub fn obstacle_call_back(&mut self) {
  28.         self.need_add_obstacle = false;
  29.     }
  31.     pub fn call_obstacle_spawn(&mut self) {
  32.         self.need_add_obstacle = true;
  33.     }
  35.     pub fn alive(&mut self) {
  36.         self.alive = true;
  37.     }
  39.     pub fn death(&mut self) {
  40.         self.alive = false;
  41.         self.score = 0;
  42.     }
  44.     pub fn get_score(&self) -> u8 {
  45.         self.score
  46.     }
  48.     pub fn add_score(&mut self) {
  49.         self.score += 1;
  50.     }
  52.     pub fn player_alive(&self) -> bool {
  53.         self.alive
  54.     }
  55. }
  57. /// 窗口大小资源
  58. #[derive(Resource)]
  59. pub struct WinSize {
  60.     pub width: f32,
  61.     pub height: f32,
  62. }
  64. /// 静态资源
  65. #[derive(Resource)]
  66. pub struct StaticAssets {
  67.     /* 图片 */
  68.     /// 玩家动画
  69.     pub player: Handle<TextureAtlas>,
  70.     /// 管道图片
  71.     pub pipe: Handle<Image>,
  72.     /// 背景图片
  73.     pub background: Handle<Image>,
  74.     /// 地面图片
  75.     pub ground: Handle<Image>,
  77.     /* 声音 */
  78.     /// 飞行声音
  79.     pub fly_audio: Handle<AudioSource>,
  80.     /// 死亡声音
  81.     pub die_audio: Handle<AudioSource>,
  82.     /// 得分声音
  83.     pub point_audio: Handle<AudioSource>,
  84.     /// 被撞击声音
  85.     pub hit_audio: Handle<AudioSource>,
  87.     /* 字体 */
  88.     /// 游戏字体
  89.     pub kenney_future_font: Handle<Font>,
  90. }
复制代码
state.rs
  1. use bevy::{
  2.     prelude::{
  3.         Color, Commands, Entity, Input, IntoSystemAppConfig, IntoSystemConfig, KeyCode, NextState,
  4.         OnEnter, OnExit, OnUpdate, Plugin, Query, Res, ResMut, States, Transform, Vec3, With,
  5.     },
  6.     text::{Text, Text2dBundle, TextAlignment, TextSection, TextStyle},
  7. };
  9. use crate::{
  10.     components::{DisplayGameOver, DisplayMenu, DisplayScore, Obstacle, Player},
  11.     constants::GROUND_IMG_SIZE,
  12.     resource::{GameData, StaticAssets, WinSize},
  13. };
  15. #[derive(Debug, Default, States, PartialEq, Eq, Clone, Hash)]
  16. pub enum GameState {
  17.     #[default]
  18.     Menu,
  19.     InGame,
  20.     Paused,
  21.     GameOver,
  22. }
  24. pub struct StatesPlugin;
  26. impl Plugin for StatesPlugin {
  27.     fn build(&self, app: &mut bevy::prelude::App) {
  28.         app
  29.             //菜单状态
  30.             .add_system(menu_display_system.in_schedule(OnEnter(GameState::Menu)))
  31.             .add_system(enter_game_system.in_set(OnUpdate(GameState::Menu)))
  32.             .add_system(exit_menu.in_schedule(OnExit(GameState::Menu)))
  33.             // 暂停状态
  34.             .add_system(enter_paused_system.in_schedule(OnEnter(GameState::Paused)))
  35.             .add_system(paused_input_system.in_set(OnUpdate(GameState::Paused)))
  36.             .add_system(paused_exit_system.in_schedule(OnExit(GameState::Paused)))
  37.             // 游戏中状态
  38.             .add_system(in_game_display_system.in_schedule(OnEnter(GameState::InGame)))
  39.             .add_system(in_game_input_system.in_set(OnUpdate(GameState::InGame)))
  40.             .add_system(exit_game_system.in_schedule(OnExit(GameState::InGame)))
  41.             // 游戏结束状态
  42.             .add_system(game_over_enter_system.in_schedule(OnEnter(GameState::GameOver)))
  43.             .add_system(in_game_over_system.in_set(OnUpdate(GameState::GameOver)))
  44.             .add_system(game_over_exit_system.in_schedule(OnExit(GameState::GameOver)));
  45.     }
  46. }
  48. //// 进入菜单页面
  49. fn menu_display_system(mut commands: Commands, static_assets: Res<StaticAssets>) {
  50.     let font = static_assets.kenney_future_font.clone();
  51.     let common_style = TextStyle {
  52.         font: font.clone(),
  53.         font_size: 32.,
  54.         color: Color::BLUE,
  55.         ..Default::default()
  56.     };
  57.     let special_style = TextStyle {
  58.         font: font.clone(),
  59.         font_size: 38.,
  60.         color: Color::RED,
  61.         ..Default::default()
  62.     };
  64.     let align = TextAlignment::Center;
  65.     commands.spawn((
  66.         Text2dBundle {
  67.             text: Text::from_sections(vec![
  68.                 TextSection::new("PRESS \r\n".to_owned(), common_style.clone()),
  69.                 TextSection::new(" SPACE \r\n".to_owned(), special_style.clone()),
  70.                 TextSection::new("START GAME!\r\n".to_owned(), common_style.clone()),
  71.                 TextSection::new(" P \r\n".to_owned(), special_style.clone()),
  72.                 TextSection::new("PAUSED GAME!\r\n".to_owned(), common_style.clone()),
  73.             ])
  74.             .with_alignment(align),
  75.             transform: Transform {
  76.                 translation: Vec3::new(0., 0., 4.),
  77.                 ..Default::default()
  78.             },
  79.             ..Default::default()
  80.         },
  81.         DisplayMenu,
  82.     ));
  83. }
  85. //// 进入游戏显示系统
  86. fn in_game_display_system(
  87.     mut commands: Commands,
  88.     win_size: Res<WinSize>,
  89.     static_assets: Res<StaticAssets>,
  90. ) {
  91.     let font = static_assets.kenney_future_font.clone();
  92.     let common_style = TextStyle {
  93.         font: font.clone(),
  94.         font_size: 32.,
  95.         color: Color::BLUE,
  96.         ..Default::default()
  97.     };
  98.     let special_style = TextStyle {
  99.         font: font.clone(),
  100.         font_size: 38.,
  101.         color: Color::RED,
  102.         ..Default::default()
  103.     };
  104.     let y = -(win_size.height / 2. - GROUND_IMG_SIZE.1 + special_style.font_size * 1.5);
  105.     let align = TextAlignment::Center;
  106.     commands.spawn((
  107.         Text2dBundle {
  108.             text: Text::from_sections(vec![
  109.                 TextSection::new("SCORE: ".to_owned(), common_style),
  110.                 TextSection::new("0".to_owned(), special_style),
  111.             ])
  112.             .with_alignment(align),
  113.             transform: Transform {
  114.                 translation: Vec3::new(0., y, 6.),
  115.                 ..Default::default()
  116.             },
  117.             ..Default::default()
  118.         },
  119.         DisplayScore,
  120.     ));
  121. }
  123. /// 进入游戏
  124. fn enter_game_system(kb: Res<Input<KeyCode>>, mut state: ResMut<NextState<GameState>>) {
  125.     if kb.just_released(KeyCode::Space) {
  126.         state.set(GameState::InGame)
  127.     }
  128. }
  130. /// 退出游戏
  131. fn exit_game_system(
  132.     mut commands: Commands,
  133.     query: Query<Entity, (With<Text>, With<DisplayScore>)>,
  134. ) {
  135.     for entity in query.iter() {
  136.         commands.entity(entity).despawn();
  137.     }
  138. }
  139. /// 退出菜单
  140. fn exit_menu(mut commands: Commands, query: Query<Entity, (With<Text>, With<DisplayMenu>)>) {
  141.     for entity in query.iter() {
  142.         commands.entity(entity).despawn();
  143.     }
  144. }
  146. /// 进入暂停状态下运行的系统
  147. pub fn enter_paused_system(mut commands: Commands, static_assets: Res<StaticAssets>) {
  148.     // 字体引入
  149.     let font = static_assets.kenney_future_font.clone();
  150.     let common_style = TextStyle {
  151.         font: font.clone(),
  152.         font_size: 32.,
  153.         color: Color::BLUE,
  154.         ..Default::default()
  155.     };
  156.     let special_style = TextStyle {
  157.         font: font.clone(),
  158.         font_size: 38.,
  159.         color: Color::RED,
  160.         ..Default::default()
  161.     };
  163.     let align = TextAlignment::Center;
  164.     commands.spawn((
  165.         Text2dBundle {
  166.             text: Text::from_sections(vec![
  167.                 TextSection::new("PAUSED  \r\n".to_owned(), common_style.clone()),
  168.                 TextSection::new(" R \r\n".to_owned(), special_style.clone()),
  169.                 TextSection::new("RETURN GAME!".to_owned(), common_style.clone()),
  170.             ])
  171.             .with_alignment(align),
  172.             transform: Transform {
  173.                 translation: Vec3::new(0., 0., 4.),
  174.                 ..Default::default()
  175.             },
  176.             ..Default::default()
  177.         },
  178.         DisplayMenu,
  179.     ));
  180. }
  182. /// 暂停状态状态下的键盘监听系统
  183. pub fn paused_input_system(kb: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<GameState>>) {
  184.     if kb.pressed(KeyCode::R) {
  185.         next_state.set(GameState::InGame);
  186.     }
  187. }
  189. /// 退出暂停状态时执行的系统
  190. pub fn paused_exit_system(
  191.     mut commands: Commands,
  192.     query: Query<Entity, (With<Text>, With<DisplayMenu>)>,
  193. ) {
  194.     for entity in query.iter() {
  195.         commands.entity(entity).despawn();
  196.     }
  197. }
  199. /// 游戏中监听暂停
  200. pub fn in_game_input_system(kb: Res<Input<KeyCode>>, mut next_state: ResMut<NextState<GameState>>) {
  201.     if kb.pressed(KeyCode::P) {
  202.         next_state.set(GameState::Paused);
  203.     }
  204. }
  206. /// 游戏结束状态下运行的系统
  207. pub fn game_over_enter_system(
  208.     mut commands: Commands,
  209.     game_data: Res<GameData>,
  210.     static_assets: Res<StaticAssets>,
  211. ) {
  212.     // 字体引入
  213.     let font = static_assets.kenney_future_font.clone();
  214.     let common_style = TextStyle {
  215.         font: font.clone(),
  216.         font_size: 32.,
  217.         color: Color::BLUE,
  218.         ..Default::default()
  219.     };
  220.     let special_style = TextStyle {
  221.         font: font.clone(),
  222.         font_size: 38.,
  223.         color: Color::RED,
  224.         ..Default::default()
  225.     };
  227.     let align = TextAlignment::Center;
  228.     commands.spawn((
  229.         Text2dBundle {
  230.             text: Text::from_sections(vec![
  231.                 TextSection::new(
  232.                     "GAME OVER !  \r\n You got ".to_owned(),
  233.                     common_style.clone(),
  234.                 ),
  235.                 TextSection::new(game_data.get_score().to_string(), special_style.clone()),
  236.                 TextSection::new(" score. \r\n  ".to_owned(), common_style.clone()),
  237.                 TextSection::new("SPACE ".to_owned(), special_style.clone()),
  238.                 TextSection::new("RESTART GAME! \r\n".to_owned(), common_style.clone()),
  239.                 TextSection::new("M ".to_owned(), special_style.clone()),
  240.                 TextSection::new("TO MENU".to_owned(), common_style.clone()),
  241.             ])
  242.             .with_alignment(align),
  243.             transform: Transform {
  244.                 translation: Vec3::new(0., 80., 4.),
  245.                 ..Default::default()
  246.             },
  247.             ..Default::default()
  248.         },
  249.         DisplayGameOver,
  250.     ));
  251. }
  253. /// 退出游戏状态时执行的系统
  254. pub fn game_over_exit_system(
  255.     mut commands: Commands,
  256.     query: Query<Entity, (With<Text>, With<DisplayGameOver>)>,
  257.     obstacle_query: Query<Entity, With<Obstacle>>,
  258.     player_query: Query<Entity, With<Player>>,
  259. ) {
  260.     for entity in query.iter() {
  261.         commands.entity(entity).despawn();
  262.     }
  263.     for entity in obstacle_query.iter() {
  264.         commands.entity(entity).despawn();
  265.     }
  266.     for entity in player_query.iter() {
  267.         commands.entity(entity).despawn();
  268.     }
  269. }
  271. /// 退出游戏状态监听
  272. pub fn in_game_over_system(
  273.     kb: Res<Input<KeyCode>>,
  274.     mut game_data: ResMut<GameData>,
  275.     mut next_state: ResMut<NextState<GameState>>,
  276. ) {
  277.     game_data.death();
  278.     if kb.pressed(KeyCode::M) {
  279.         next_state.set(GameState::Menu);
  280.     } else if kb.pressed(KeyCode::Space) {
  281.         next_state.set(GameState::InGame);
  282.     }
  283. }
复制代码
Cargo.toml
  1. [package]
  2. name = "flappy_bird_bevy"
  3. version = "0.1.0"
  4. edition = "2021"
  6. # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
  8. [dependencies]
  9. bevy = { version = "0.10.1" }
  10. rand = "0.8.5"
  12. [workspace]
  13. resolver = "2"
复制代码
about me

目前失业，在家学习 rust 。
我的 bilibili,我的 Github。
Rust官网
Rust 中文社区

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

锦通

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表