一个简单的 rust 项目 飞机大战

Rust 实现的飞机游戏

简介

一个使用 bevy 引擎制作的飞机游戏。
原视频教程地址,github 地址。
因为 bevy 已经升级到 0.10.1 了，所以重新做一遍。顺带手出个教程。
下面是做的部分变动：

• 将激光以及玩家的移动模块进行了拆分。
  
• 新增了背景图片。
  
• 新增了游戏状态管理 Welcome/InGame/Paused。
  
• 新增了声音播放模块。
  
• 新增了游戏记分板。
  

通过左右方向键进行控制，使用空格发射激光。
按 P 暂停游戏，按 S 恢复游戏。
更新后的GitHub地址
代码结构

1. ·
2. ├── assets/
3. │   ├──audios/
4. │   ├──images/
5. ├── src/
6. │   ├──enemy/
7. │   │  ├── formation.rs
8. │   │  └── mod.rs
9. │   ├── components.rs
10. │   ├── constants.rs
11. │   ├── main.rs
12. │   ├── player.rs
13. │   ├── resource.rs
14. │   └── state.rs
15. ├── Cargo.lock
16. └── Cargo.toml

复制代码

• assets/audios 声音资源文件。
  
• assets/images 图片资源文件。
  
• enemy/formation.rs 敌人阵型系统的实现。
  
• enemy/mod.rs 敌人插件，生成、移动、攻击的实现。
  
• components.rs 负责游戏的逻辑、控制、等内容。
  
• constants.rs 负责存储游戏中用到的常量。
  
• main.rs 负责游戏的逻辑、控制、等内容。
  
• player.rs 玩家角色插件，生成、移动、攻击、键盘处理的实现。
  
• resource.rs 游戏资源定义。
  
• state.rs 游戏组件定义。
  

两点间的距离公式 \(|AB|=\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}\)

enemy/formation.rs

1. use bevy::prelude::{Component, Resource};
2. use rand::{thread_rng, Rng};
4. use crate::{WinSize, BASE_SPEED, FORMATION_MEMBER_MAX};
6. /// 敌人阵型
7. #[derive(Component, Clone)]
8. pub struct Formation {
9.     /// 启始位置
10.     pub start: (f32, f32),
11.     /// 半径
12.     pub radius: (f32, f32),
13.     /// 原点
14.     pub pivot: (f32, f32),
15.     /// 速度
16.     pub speed: f32,
17.     /// 角度
18.     pub angle: f32,
19. }
21. /// 阵型资源
22. #[derive(Resource, Default)]
23. pub struct FormationMaker {
24.     /// 当前阵型
25.     current_template: Option<Formation>,
26.     /// 当前数量
27.     current_members: u32,
28. }
30. impl FormationMaker {
31.     pub fn make(&mut self, win_size: &WinSize) -> Formation {
32.         match (
33.             &self.current_template,
34.             self.current_members >= FORMATION_MEMBER_MAX,
35.         ) {
36.             // 当前阵型还有空位 直接加入
37.             (Some(template), false) => {
38.                 self.current_members += 1;
39.                 template.clone()
40.             }
41.             // 当前阵型没有空位，或还没有阵型，需要创建新的阵型
42.             _ => {
43.                 let mut rng = thread_rng();
45.                 // 生成 起点坐标
46.                 let w_spawn = win_size.w / 2. + 100.;
47.                 let h_spawn = win_size.h / 2. + 100.;
48.                 let x = if rng.gen_bool(0.5) { w_spawn } else { -w_spawn };
49.                 let y = rng.gen_range(-h_spawn..h_spawn);
50.                 let start = (x, y);
52.                 // 生成原点坐标
53.                 let w_spawn = win_size.w / 4.;
54.                 let h_spawn = win_size.h / 3. + 50.;
55.                 let pivot = (
56.                     rng.gen_range(-w_spawn..w_spawn),
57.                     rng.gen_range(0. ..h_spawn),
58.                 );
60.                 // 生成半径
61.                 let radius = (rng.gen_range(80. ..150.), 100.);
63.                 // 计算初始角度
64.                 let angle = (y - pivot.1).atan2(x - pivot.0);
66.                 // 速度
67.                 let speed = BASE_SPEED;
69.                 let formation = Formation {
70.                     start,
71.                     pivot,
72.                     radius,
73.                     angle,
74.                     speed,
75.                 };
77.                 self.current_template = Some(formation.clone());
78.                 self.current_members = 1;
79.                 formation
80.             }
81.         }
82.     }
83. }

复制代码

enemy/mod.rs

1. use std::{f32::consts::PI, time::Duration};
3. use crate::{
4.     components::{Enemy, FromEnemy, Laser, Movable, SpriteSize, Velocity},
5.     resource::GameState,
6.     GameTextures, MaxEnemy, WinSize, ENEMY_LASER_SIZE, ENEMY_SIZE, MAX_ENEMY, SPRITE_SCALE,
7.     TIME_STEP,
8. };
10. use bevy::{prelude::*, time::common_conditions::on_timer};
11. use rand::{thread_rng, Rng};
13. use self::formation::{Formation, FormationMaker};
15. mod formation;
17. #[derive(Component)]
18. pub struct EnemyPlugin;
20. impl Plugin for EnemyPlugin {
21.     fn build(&self, app: &mut App) {
22.         // 间隔执行
23.         app.insert_resource(FormationMaker::default())
24.             .add_system(
25.                 enemy_spawn_system
26.                     .run_if(on_timer(Duration::from_secs_f32(0.5)))
27.                     .in_set(OnUpdate(GameState::InGame)),
28.             )
29.             .add_system(
30.                 enemy_fire_system
31.                     .run_if(enemy_fire_criteria)
32.                     .in_set(OnUpdate(GameState::InGame)),
33.             )
34.             .add_system(enemy_movement_system.in_set(OnUpdate(GameState::InGame)));
35.     }
36. }
38. /// 敌人生成系统
39. fn enemy_spawn_system(
40.     mut commands: Commands,
41.     mut max_enemy: ResMut<MaxEnemy>,
42.     mut formation_maker: ResMut<FormationMaker>,
43.     game_textures: Res<GameTextures>,
44.     win_size: Res<WinSize>,
45. ) {
46.     // 如果当前的敌人数量大于等于最大敌人数量，则不再产生新的敌人
47.     if max_enemy.0 >= MAX_ENEMY {
48.         return;
49.     }
51.     // 随机生成
52.     // let mut rng = thread_rng();
53.     // let w_span = win_size.w / 2. - 100.;
54.     // let h_span = win_size.h / 2. - 100.;
55.     // let x = rng.gen_range(-w_span..w_span);
56.     // let y = rng.gen_range(-h_span..h_span);
58.     // 使用 阵型
59.     let formation = formation_maker.make(&win_size);
60.     let (x, y) = formation.start;
62.     commands
63.         .spawn(SpriteBundle {
64.             texture: game_textures.enemy.clone(),
65.             transform: Transform {
66.                 // 坐标
67.                 translation: Vec3::new(x, y, 10.),
68.                 // 缩放
69.                 scale: Vec3::new(SPRITE_SCALE, SPRITE_SCALE, 1.),
70.                 // 旋转
71.                 rotation: Quat::IDENTITY,
72.             },
73.             ..Default::default()
74.         })
75.         .insert(Enemy)
76.         .insert(formation)
77.         .insert(SpriteSize::from(ENEMY_SIZE));
78.     max_enemy.0 += 1;
79. }
81. /// 敌人射击系统
82. fn enemy_fire_system(
83.     mut commands: Commands,
84.     game_textures: Res<GameTextures>,
85.     query: Query<&Transform, With<Enemy>>,
86. ) {
87.     for &enemy_tf in query.iter() {
88.         let (x, y) = (enemy_tf.translation.x, enemy_tf.translation.y);
90.         commands
91.             .spawn(SpriteBundle {
92.                 texture: game_textures.enemy_laser.clone(),
93.                 transform: Transform {
94.                     translation: Vec3::new(x, y, 1.),
95.                     scale: Vec3::new(SPRITE_SCALE, SPRITE_SCALE, 1.),
96.                     rotation: Quat::from_rotation_x(PI),
97.                 },
98.                 ..Default::default()
99.             })
100.             .insert(Laser)
101.             .insert(SpriteSize::from(ENEMY_LASER_SIZE))
102.             .insert(FromEnemy)
103.             .insert(Movable { auto_despawn: true })
104.             .insert(Velocity::new(0., -1.));
105.     }
106. }
108. /// 是否发射攻击
109. fn enemy_fire_criteria() -> bool {
110.     if thread_rng().gen_bool(1. / 60.) {
111.         true
112.     } else {
113.         false
114.     }
115. }
117. /// 敌人移动系统
118. ///
119. /// 两点间的距离公式 $|AB|=\sqrt{(x_1-x_2)^2+(y_1-y_2)^2}$
120. fn enemy_movement_system(mut query: Query<(&mut Transform, &mut Formation), With<Enemy>>) {
121.     // 当前时间
122.     // let now = time.elapsed_seconds();
123.     for (mut transform, mut formation) in query.iter_mut() {
124.         // 当前坐标
125.         let (x_org, y_org) = (transform.translation.x, transform.translation.y);
126.         // let (x_org, y_org) = formation.start;
128.         // 单位时间内最大移动距离
129.         // let max_distance = BASE_SPEED * TIME_STEP;
130.         let max_distance = formation.speed * TIME_STEP;
132.         // 方向 1 顺时针 -1 逆时针
133.         // let dir = -1.;
134.         let dir = if formation.start.0 < 0. { 1. } else { -1. };
135.         // 中心点
136.         // let (x_pivot, y_pivot) = (0., 0.);
137.         let (x_pivot, y_pivot) = formation.pivot;
138.         // 半径
139.         // let (x_radius, y_radius) = (200., 130.);
140.         let (x_radius, y_radius) = formation.radius;
142.         // 基于当前时间计算的角度
143.         // let angel = dir * BASE_SPEED * TIME_STEP * now % 360. / PI;
144.         let angel = formation.angle
145.             + dir * formation.speed * TIME_STEP / (x_radius.min(y_radius) * PI / 2.);
147.         // 计算目标点位
148.         let x_dst = x_radius * angel.cos() + x_pivot;
149.         let y_dst = y_radius * angel.sin() + y_pivot;
151.         // 计算距离
152.         // 两点间的距离公式 根号下 a.x - b.x
153.         let dx = x_org - x_dst;
154.         let dy = y_org - y_dst;
156.         let distance = (dx * dx + dy * dy).sqrt();
157.         let distance_radio = if distance != 0. {
158.             max_distance / distance
159.         } else {
160.             0.
161.         };
163.         // 计算 x y 的最终坐标
164.         let x = x_org - dx * distance_radio;
165.         let x = if dx > 0. { x.max(x_dst) } else { x.min(x_dst) };
166.         let y = y_org - dy * distance_radio;
167.         let y = if dy > 0. { y.max(y_dst) } else { y.min(y_dst) };
169.         // 图片资源在椭圆上 或接近椭圆时开始加入旋转
170.         if distance < max_distance * formation.speed / 20. {
171.             formation.angle = angel;
172.         }
174.         let translation = &mut transform.translation;
175.         (translation.x, translation.y) = (x, y);
176.     }
177. }

复制代码

components.rs

1. use bevy::{
2.     prelude::{Component, Vec2, Vec3},
3.     time::{Timer, TimerMode},
4. };
6. // 通用控制组件
7. #[derive(Component)]
8. pub struct Velocity {
9.     pub x: f32,
10.     pub y: f32,
11. }
12. impl Velocity {
13.     pub fn new(x: f32, y: f32) -> Self {
14.         Self { x, y }
15.     }
16. }
18. /// 移动能力组件
19. #[derive(Component)]
20. pub struct Movable {
21.     /// 自动销毁
22.     pub auto_despawn: bool,
23. }
25. /// 玩家组件
26. #[derive(Component)]
27. pub struct Player;
29. /// 玩家信息组件
30. #[derive(Component)]
31. pub struct FromPlayer;
33. /// 敌人组件
34. #[derive(Component)]
35. pub struct Enemy;
37. /// 敌人信息组件
38. #[derive(Component)]
39. pub struct FromEnemy;
41. /// 激光组件
42. #[derive(Component)]
43. pub struct Laser;
45. /// 图片大小组件
46. #[derive(Component)]
47. pub struct SpriteSize(pub Vec2);
49. /// 实现 (f32,f32) 转 SpritSize
50. impl From<(f32, f32)> for SpriteSize {
51.     fn from(value: (f32, f32)) -> Self {
52.         Self(Vec2::new(value.0, value.1))
53.     }
54. }
56. /// 爆炸组件
57. #[derive(Component)]
58. pub struct Explosion;
60. /// 产生爆炸组件
61. #[derive(Component)]
62. pub struct ExplosionToSpawn(pub Vec3);
64. /// 爆炸事件组件
65. #[derive(Component)]
66. pub struct ExplosionTimer(pub Timer);
68. impl Default for ExplosionTimer {
69.     fn default() -> Self {
70.         Self(Timer::from_seconds(0.05, TimerMode::Once))
71.     }
72. }
74. /// 分数显示组件
75. #[derive(Component)]
76. pub struct DisplayScore;
78. /// 欢迎组件
79. #[derive(Component)]
80. pub struct WelcomeText;
82. /// 暂停组件
83. #[derive(Component)]
84. pub struct PausedText;

复制代码

constants.rs

1. /// 游戏背景图片路径
2. pub const BACKGROUND_SPRITE: &str = "images/planet05.png";
4. /// 玩家图片路径
5. pub const PLAYER_SPRITE: &str = "images/player_a_01.png";
6. /// 玩家大小
7. pub const PLAYER_SIZE: (f32, f32) = (144., 75.);
8. /// 玩家攻击图片路径
9. pub const PLAYER_LASER_SPRITE: &str = "images/laser_a_01.png";
10. /// 玩家攻击图片大小
11. pub const PLAYER_LASER_SIZE: (f32, f32) = (9., 54.);
13. /// 敌人图片路径
14. pub const ENEMY_SPRITE: &str = "images/enemy_a_01.png";
15. /// 敌人大小
16. pub const ENEMY_SIZE: (f32, f32) = (144., 75.);
17. /// 敌人攻击图片路径
18. pub const ENEMY_LASER_SPRITE: &str = "images/laser_b_01.png";
19. /// 敌人攻击图片大小
20. pub const ENEMY_LASER_SIZE: (f32, f32) = (17., 55.);
22. /// 爆炸图片路径
23. pub const EXPLOSION_SHEET: &str = "images/explosion_a_sheet.png";
24. /// 爆炸图片大小
25. pub const EXPLOSION_SIZE: (f32, f32) = (64., 64.);
26. /// 爆炸画面帧数
27. pub const EXPLOSION_ANIMATION_LEN: usize = 16;
29. /// 图片缩放比例
30. pub const SPRITE_SCALE: f32 = 0.5;
32. /// 步长 (帧数)
33. pub const TIME_STEP: f32 = 1. / 60.;
34. /// 基础速度
35. pub const BASE_SPEED: f32 = 500.;
36. /// 敌人最大数量
37. pub const MAX_ENEMY: u32 = 2;
38. /// 玩家自动重生时间
39. pub const PLAYER_RESPAWN_DELAY: f64 = 2.;
40. /// 阵型内敌人最大数量
41. pub const FORMATION_MEMBER_MAX: u32 = 2;
43. /// 敌人被摧毁声音
44. pub const ENEMY_EXPLOSION_AUDIO: &str = "audios/enemy_explosion.ogg";
45. /// 玩家被摧毁的声音
46. pub const PLAYER_EXPLOSION_AUDIO: &str = "audios/player_explosion.ogg";
47. /// 玩家发射激光的声音
48. pub const PLAYER_LASER_AUDIO: &str = "audios/player_laser.ogg";
50. /// 字体路径
51. pub const KENNEY_BLOCK_FONT: &str = "fonts/kenney_blocks.ttf";

复制代码

main.rs

1. use bevy::{math::Vec3Swizzles, prelude::*, sprite::collide_aabb::collide, utils::HashSet};
2. use components::*;
4. use constants::*;
5. use enemy::EnemyPlugin;
6. use player::PlayerPlugin;
7. use resource::{GameAudio, GameData, GameState, GameTextures, MaxEnemy, PlayerState, WinSize};
8. use state::StatePlugin;
10. mod components;
11. mod constants;
12. mod enemy;
13. mod player;
14. mod resource;
15. mod state;
17. fn main() {
18.     // add_startup_system 启动生命周期时只运行一次 ，
19.     // add_system 每帧都会被调用方法
20.     App::new()
21.         .add_state::<GameState>()
22.         .insert_resource(ClearColor(Color::rgb(0.04, 0.04, 0.04)))
23.         .add_plugins(DefaultPlugins.set(WindowPlugin {
24.             primary_window: Some(Window {
25.                 title: "Invaders".to_owned(),
26.                 resolution: (598., 676.).into(),
27.                 position: WindowPosition::At(IVec2::new(2282, 0)),
28.                 ..Window::default()
29.             }),
30.             ..WindowPlugin::default()
31.         }))
32.         .add_plugin(PlayerPlugin)
33.         .add_plugin(EnemyPlugin)
34.         .add_plugin(StatePlugin)
35.         .add_startup_system(setup_system)
36.         // InGame 状态下执行的函数
37.         .add_systems(
38.             (
39.                 laser_movable_system,
40.                 player_laser_hit_enemy_system,
41.                 explosion_to_spawn_system,
42.                 explosion_animation_system,
43.                 enemy_laser_hit_player_system,
44.                 score_display_update_system,
45.             )
46.                 .in_set(OnUpdate(GameState::InGame)),
47.         )
48.         // 启动 esc 键退出程序
49.         .add_system(bevy::window::close_on_esc)
50.         .run();
51. }
53. /// 资源加载
54. fn setup_system(
55.     mut commands: Commands,
56.     asset_server: Res<AssetServer>,
57.     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
58.     mut windows: Query<&mut Window>,
59. ) {
60.     // 创建2d镜头
61.     commands.spawn(Camera2dBundle::default());
63.     // 获取当前窗口
64.     let window = windows.single_mut();
65.     let win_w = window.width();
66.     let win_h = window.height();
68.     //  添加 WinSize 资源
69.     let win_size = WinSize { w: win_w, h: win_h };
70.     commands.insert_resource(win_size);
72.     // 创建爆炸动画
73.     let texture_handle = asset_server.load(EXPLOSION_SHEET);
74.     let texture_atlas =
75.         TextureAtlas::from_grid(texture_handle, Vec2::from(EXPLOSION_SIZE), 4, 4, None, None);
76.     let explosion = texture_atlases.add(texture_atlas);
78.     // 添加 GameTextures
79.     let game_texture = GameTextures {
80.         background: asset_server.load(BACKGROUND_SPRITE),
81.         player: asset_server.load(PLAYER_SPRITE),
82.         player_laser: asset_server.load(PLAYER_LASER_SPRITE),
83.         enemy: asset_server.load(ENEMY_SPRITE),
84.         enemy_laser: asset_server.load(ENEMY_LASER_SPRITE),
85.         font: asset_server.load(KENNEY_BLOCK_FONT),
86.         explosion,
87.     };
89.     // 声音资源引入
90.     let game_audio = GameAudio {
91.         player_laser: asset_server.load(PLAYER_LASER_AUDIO),
92.         player_explosion: asset_server.load(PLAYER_EXPLOSION_AUDIO),
93.         enemy_explosion: asset_server.load(ENEMY_EXPLOSION_AUDIO),
94.     };
96.     // 背景图片
97.     commands.spawn(SpriteBundle {
98.         texture: game_texture.background.clone(),
99.         sprite: Sprite {
100.             custom_size: Some(Vec2 { x: win_w, y: win_h }),
101.             ..Default::default()
102.         },
103.         transform: Transform::from_scale(Vec3::new(1.5, 1.5, 0.0)),
104.         ..Default::default()
105.     });
107.     // 字体引入
108.     let font = game_texture.font.clone();
109.     let text_style = TextStyle {
110.         font: font.clone(),
111.         font_size: 32.,
112.         color: Color::ANTIQUE_WHITE,
113.     };
114.     let text_alignment = TextAlignment::Center;
116.     // 分数展示控件
117.     commands.spawn((
118.         Text2dBundle {
119.             text: Text::from_section("SCORE:0", text_style).with_alignment(text_alignment),
120.             transform: Transform {
121.                 translation: Vec3 {
122.                     x: 0.,
123.                     y: win_h / 2. - 20.,
124.                     z: 11.,
125.                 },
126.                 ..Default::default()
127.             },
128.             ..Default::default()
129.         },
130.         DisplayScore,
131.     ));
133.     let game_data = GameData::new();
134.     commands.insert_resource(game_data);
135.     commands.insert_resource(game_audio);
136.     commands.insert_resource(game_texture);
137.     commands.insert_resource(MaxEnemy(0));
138. }
140. /// 激光移动系统
141. fn laser_movable_system(
142.     mut commands: Commands,
143.     win_size: Res<WinSize>,
144.     mut query: Query<(Entity, &Velocity, &mut Transform, &Movable), With<Laser>>,
145. ) {
146.     for (entity, velocity, mut transform, movable) in query.iter_mut() {
147.         // 移动位置
148.         let translation = &mut transform.translation;
149.         translation.x += velocity.x * BASE_SPEED * TIME_STEP;
150.         translation.y += velocity.y * BASE_SPEED * TIME_STEP;
152.         // 自动销毁
153.         if movable.auto_despawn {
154.             const MARGIN: f32 = 200.;
155.             if translation.y > win_size.h / 2. + MARGIN
156.                 || translation.y < -win_size.h / 2. - MARGIN
157.                 || translation.x > win_size.w / 2. + MARGIN
158.                 || translation.x < -win_size.w / 2. - MARGIN
159.             {
160.                 commands.entity(entity).despawn();
161.             }
162.         }
163.     }
164. }
166. /// 敌人激光攻击玩家判定系统
167. fn enemy_laser_hit_player_system(
168.     mut commands: Commands,
169.     mut player_state: ResMut<PlayerState>,
170.     time: Res<Time>,
171.     audio_source: Res<GameAudio>,
172.     audio: Res<Audio>,
173.     mut game_data: ResMut<GameData>,
174.     mut next_state: ResMut<NextState<GameState>>,
175.     laser_query: Query<(Entity, &Transform, &SpriteSize), (With<Laser>, With<FromEnemy>)>,
176.     player_query: Query<(Entity, &Transform, &SpriteSize), With<Player>>,
177. ) {
178.     if let Ok((player_entity, player_tf, player_size)) = player_query.get_single() {
179.         let player_scale = Vec2::from(player_tf.scale.xy());
181.         for (laser, laser_tf, laser_size) in laser_query.into_iter() {
182.             let laser_scale = Vec2::from(laser_tf.scale.xy());
184.             let collision = collide(
185.                 player_tf.translation,
186.                 player_size.0 * player_scale,
187.                 laser_tf.translation,
188.                 laser_size.0 * laser_scale,
189.             );
191.             if let Some(_) = collision {
192.                 // 播放音乐
193.                 audio.play(audio_source.player_explosion.clone());
194.                 // 重置分数
195.                 game_data.reset_score();
196.                 next_state.set(GameState::Welcome);
197.                 // 销毁角色
198.                 commands.entity(player_entity).despawn();
199.                 // 记录被命中的时刻
200.                 player_state.shot(time.elapsed_seconds_f64());
201.                 // 销毁激光
202.                 commands.entity(laser).despawn();
203.                 // 产生爆炸动画
204.                 commands.spawn(ExplosionToSpawn(player_tf.translation.clone()));
205.                 break;
206.             }
207.         }
208.     }
209. }
211. /// 玩家攻击敌人判定系统
212. fn player_laser_hit_enemy_system(
213.     mut commands: Commands,
214.     audio_source: Res<GameAudio>,
215.     audio: Res<Audio>,
216.     mut max_enemy: ResMut<MaxEnemy>,
217.     mut game_data: ResMut<GameData>,
218.     laser_query: Query<(Entity, &Transform, &SpriteSize), (With<Laser>, With<FromPlayer>)>,
219.     enemy_query: Query<(Entity, &Transform, &SpriteSize), With<Enemy>>,
220. ) {
221.     // 重复删除检测
222.     let mut despawn_entities: HashSet<Entity> = HashSet::new();
223.     // 玩家激光
224.     for (laser_entity, laser_tf, laser_size) in laser_query.iter() {
225.         if despawn_entities.contains(&laser_entity) {
226.             continue;
227.         }
229.         // 玩家激光的坐标
230.         let laser_scale = Vec2::from(laser_tf.scale.xy());
232.         // 敌人
233.         for (enemy_entity, enemy_tf, enemy_size) in enemy_query.iter() {
234.             if despawn_entities.contains(&enemy_entity) || despawn_entities.contains(&laser_entity)
235.             {
236.                 continue;
237.             }
239.             // 敌人坐标
240.             let enemy_scale = Vec2::from(enemy_tf.scale.xy());
242.             // collide 定义两个元素的碰撞，a 点坐标，a 的大小，b 点坐标，b 的大小,如果未发生碰撞返回 None
243.             let collision = collide(
244.                 laser_tf.translation,
245.                 laser_size.0 * laser_scale,
246.                 enemy_tf.translation,
247.                 enemy_size.0 * enemy_scale,
248.             );
250.             // 碰撞检测
251.             if let Some(_) = collision {
252.                 // 敌人数量 -1
253.                 if max_enemy.0 != 0 {
254.                     max_enemy.0 -= 1;
255.                 }
256.                 game_data.add_score();
258.                 audio.play(audio_source.enemy_explosion.clone());
259.                 // 销毁敌人
260.                 commands.entity(enemy_entity).despawn();
261.                 despawn_entities.insert(enemy_entity);
262.                 // 销毁激光
263.                 commands.entity(laser_entity).despawn();
264.                 despawn_entities.insert(laser_entity);
266.                 // 播放爆炸动画
267.                 commands.spawn(ExplosionToSpawn(enemy_tf.translation.clone()));
268.             }
269.         }
270.     }
271. }
273. /// 爆炸画面生成系统
274. fn explosion_to_spawn_system(
275.     mut commands: Commands,
276.     game_textures: Res<GameTextures>,
277.     query: Query<(Entity, &ExplosionToSpawn)>,
278. ) {
279.     for (explosion_spawn_entity, explosion_to_spawn) in query.iter() {
280.         commands
281.             .spawn(SpriteSheetBundle {
282.                 texture_atlas: game_textures.explosion.clone(),
283.                 transform: Transform {
284.                     translation: explosion_to_spawn.0,
285.                     ..Default::default()
286.                 },
287.                 ..Default::default()
288.             })
289.             .insert(Explosion)
290.             .insert(ExplosionTimer::default());
292.         commands.entity(explosion_spawn_entity).despawn();
293.     }
294. }
296. /// 爆炸动画系统
297. fn explosion_animation_system(
298.     mut commands: Commands,
299.     time: Res<Time>,
300.     mut query: Query<(Entity, &mut ExplosionTimer, &mut TextureAtlasSprite), With<Explosion>>,
301. ) {
302.     for (entity, mut timer, mut texture_atlas_sprite) in query.iter_mut() {
303.         timer.0.tick(time.delta());
305.         if timer.0.finished() {
306.             texture_atlas_sprite.index += 1;
307.             if texture_atlas_sprite.index >= EXPLOSION_ANIMATION_LEN {
308.                 commands.entity(entity).despawn();
309.             }
310.         }
311.     }
312. }
314. /// 分数更新系统
315. fn score_display_update_system(
316.     game_data: Res<GameData>,
317.     mut query: Query<&mut Text, With<DisplayScore>>,
318. ) {
319.     for mut text in &mut query {
320.         let new_str: String = format!("SCORE:{}", game_data.get_score());
321.         text.sections[0].value = new_str;
322.     }
323. }

复制代码

player.rs

1. use bevy::{prelude::*, time::common_conditions::on_timer};
2. use std::time::Duration;
4. use crate::{
5.     components::{FromPlayer, Laser, Movable, Player, SpriteSize, Velocity},
6.     resource::GameAudio,
7.     resource::PlayerState,
8.     resource::WinSize,
9.     resource::{GameState, GameTextures},
10.     BASE_SPEED, PLAYER_LASER_SIZE, PLAYER_RESPAWN_DELAY, PLAYER_SIZE, SPRITE_SCALE, TIME_STEP,
11. };
13. pub struct PlayerPlugin;
15. impl Plugin for PlayerPlugin {
16.     fn build(&self, app: &mut App) {
17.         // add_startup_system 应用程序生命周期开始时运行一次
18.         // StartupSet::PostStartup 在 StartupSet::Startup 后运行一次
19.         // add_startup_system(player_spawn_system.in_base_set(StartupSet::PostStartup))
20.         // add_system 每帧都运行 , 可以在函数后通过 run_if 传入 bool 类型的条件进行限制
21.         app.insert_resource(PlayerState::default())
22.             .add_system(
23.                 player_spawn_system
24.                     .run_if(on_timer(Duration::from_secs_f32(0.5)))
25.                     .in_set(OnUpdate(GameState::InGame)),
26.             )
27.             .add_systems(
28.                 (
29.                     player_keyboard_event_system,
30.                     player_movable_system,
31.                     player_fire_system,
32.                 )
33.                     .in_set(OnUpdate(GameState::InGame)),
34.             );
35.     }
36. }
38. /// 玩家角色生成系统
39. fn player_spawn_system(
40.     mut commands: Commands,
41.     mut player_state: ResMut<PlayerState>,
42.     time: Res<Time>,
43.     game_textures: Res<GameTextures>,
44.     win_size: Res<WinSize>,
45. ) {
46.     let now = time.elapsed_seconds_f64();
47.     let last_shot = player_state.last_shot;
48.     if !player_state.on && (player_state.last_shot == -1. || now - PLAYER_RESPAWN_DELAY > last_shot)
49.     {
50.         let bottom = -win_size.h / 2.;
52.         // 创建组件实体，并返回对应的 EntityCommand
53.         commands
54.             .spawn(SpriteBundle {
55.                 texture: game_textures.player.clone(),
56.                 transform: Transform {
57.                     translation: Vec3::new(
58.                         0.,
59.                         bottom + PLAYER_SIZE.1 / 2. * SPRITE_SCALE + 5.0,
60.                         10.,
61.                     ),
62.                     scale: Vec3::new(SPRITE_SCALE, SPRITE_SCALE, 1.0),
63.                     ..default()
64.                 },
65.                 ..SpriteBundle::default()
66.             })
67.             .insert(Velocity::new(0., 0.))
68.             .insert(Movable {
69.                 auto_despawn: false,
70.             })
71.             .insert(SpriteSize::from(PLAYER_SIZE))
72.             .insert(Player);
74.         player_state.spawned();
75.     }
76. }
78. /// 玩家攻击系统
79. fn player_fire_system(
80.     mut commands: Commands,
81.     audio_source: Res<GameAudio>,
82.     audio: Res<Audio>,
83.     kb: Res<Input<KeyCode>>,
84.     game_textures: Res<GameTextures>,
85.     query: Query<&Transform, With<Player>>,
86. ) {
87.     if let Ok(player_tf) = query.get_single() {
88.         // just_released 松开按键
89.         if kb.just_released(KeyCode::Space) {
90.             audio.play(audio_source.player_laser.clone());
91.             let (x, y) = (player_tf.translation.x, player_tf.translation.y);
93.             let x_offset = PLAYER_SIZE.0 / 2. * SPRITE_SCALE - 5.;
95.             // 激光生成闭包 因为这里使用了 commands 生成新的包 所以这里的闭包需要定义为 mut 类型
96.             let mut spawn_laser = |x_offset: f32| {
97.                 commands
98.                     .spawn(SpriteBundle {
99.                         texture: game_textures.player_laser.clone(),
100.                         transform: Transform {
101.                             translation: Vec3::new(x + x_offset, y + 15., 1.),
102.                             scale: Vec3::new(SPRITE_SCALE, SPRITE_SCALE, 0.),
103.                             ..Default::default()
104.                         },
105.                         ..Default::default()
106.                     })
107.                     .insert(Laser)
108.                     .insert(FromPlayer)
109.                     .insert(SpriteSize::from(PLAYER_LASER_SIZE))
110.                     .insert(Movable { auto_despawn: true })
111.                     .insert(Velocity::new(0., 1.));
112.             };
113.             spawn_laser(x_offset);
114.             spawn_laser(-x_offset);
115.         }
116.     }
117. }
119. /// 键盘事件系统
120. fn player_keyboard_event_system(
121.     kb: Res<Input<KeyCode>>,
122.     mut next_state: ResMut<NextState<GameState>>,
123.     mut query: Query<&mut Velocity, With<Player>>,
124. ) {
125.     if let Ok(mut velocity) = query.get_single_mut() {
126.         // pressed 按下按键
127.         if kb.pressed(KeyCode::Left) {
128.             velocity.x = -1.
129.         } else if kb.pressed(KeyCode::Right) {
130.             velocity.x = 1.
131.         } else if kb.just_pressed(KeyCode::P) {
132.             next_state.set(GameState::Paused);
133.         } else {
134.             velocity.x = 0.
135.         }
136.     };
137. }
139. /// 玩家移动系统
140. fn player_movable_system(
141.     win_size: Res<WinSize>,
142.     mut query: Query<(&Velocity, &mut Transform), With<Player>>,
143. ) {
144.     let max_w = win_size.w / 2.;
146.     for (velocity, mut transform) in query.iter_mut() {
147.         let distance = velocity.x * BASE_SPEED * TIME_STEP;
148.         let new_x = transform.translation.x + distance;
149.         if -max_w <= new_x && new_x <= max_w {
150.             // 移动位置
151.             transform.translation.x += distance;
152.         }
153.     }
154. }

复制代码

state.rs

1. use bevy::{
2.     prelude::{AudioSource, Handle, Image, Resource, States},
3.     sprite::TextureAtlas,
4.     text::Font,
5. };
7. /// 游戏窗口大小资源
8. #[derive(Resource)]
9. pub struct WinSize {
10.     pub w: f32,
11.     pub h: f32,
12. }
14. /// 游戏图像资源
15. #[derive(Resource)]
16. pub struct GameTextures {
17.     pub background: Handle<Image>,
18.     pub player: Handle<Image>,
19.     pub player_laser: Handle<Image>,
20.     pub enemy: Handle<Image>,
21.     pub enemy_laser: Handle<Image>,
22.     pub explosion: Handle<TextureAtlas>,
23.     pub font: Handle<Font>,
24. }
26. /// 敌人最大数量
27. #[derive(Resource)]
28. pub struct MaxEnemy(pub u32);
30. /// 玩家状态
31. #[derive(Resource)]
32. pub struct PlayerState {
33.     pub on: bool,
34.     pub last_shot: f64,
35. }
37. impl Default for PlayerState {
38.     fn default() -> Self {
39.         Self {
40.             on: false,
41.             last_shot: -1.,
42.         }
43.     }
44. }
46. impl PlayerState {
47.     /// 被命中
48.     pub fn shot(&mut self, time: f64) {
49.         self.on = false;
50.         self.last_shot = time;
51.     }
52.     /// 重生
53.     pub fn spawned(&mut self) {
54.         self.on = true;
55.         self.last_shot = -1.;
56.     }
57. }
59. #[derive(Resource)]
60. pub struct GameAudio {
61.     pub enemy_explosion: Handle<AudioSource>,
62.     pub player_explosion: Handle<AudioSource>,
63.     pub player_laser: Handle<AudioSource>,
64. }
66. /// 游戏状态   
67. #[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Hash, States)]
68. pub enum GameState {
69.     /// 欢迎
70.     #[default]
71.     Welcome,
72.     /// 游戏中
73.     InGame,
74.     /// 暂停
75.     Paused,
76. }
78. /// 游戏数据
79. #[derive(Resource)]
80. pub struct GameData {
81.     score: u32,
82. }
84. impl GameData {
85.     pub fn new() -> Self {
86.         Self { score: 0 }
87.     }
89.     /// 获取当前得分
90.     pub fn get_score(&self) -> u32 {
91.         self.score
92.     }
94.     /// 增加得分
95.     pub fn add_score(&mut self) {
96.         self.score += 1;
97.     }
99.     /// 增加得分
100.     pub fn reset_score(&mut self) {
101.         self.score = 0;
102.     }
103. }

复制代码

about me

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

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