一个简单的 rust项目 flappy bird

一个非常简单的小项目。
看到了杨旭大佬的教学视频，自己跟着实现了一下，完善了一下游戏逻辑。
通过空格键进行控制。
游戏中可按 P 键 暂停/恢复 游戏

项目结构

1. ·
2. ├── Cargo.lock
3. ├── Cargo.toml
4. ├── src/
5. │   ├── main.rs
6. │   ├──bird/
7. │   │  ├── bird.rs
8. │   │  └── mod.rs
9. │   ├──game/
10. │   │   ├── game.rs
11. │   │   └── mod.rs
12. │   └──obstacles/
13. │       ├──obstacle.rs
14. │       └── mod.rs

复制代码

• game.rs 负责游戏的逻辑、控制、等内容。
  
• bird.rs 负责小鸟本身的实现。
  
• obstacle.rs 负责障碍物的实现。
  

三个mod.rs 文件

1. // game/mod.rs
2. pub mod game;
4. // bird/mod.rs
5. pub mod bird;
7. // obstacles/mod.rs
8. pub mod obstacle;

复制代码

main.rs

1. use bracket_lib::prelude::{main_loop, BError, BTermBuilder};
3. pub mod bird;
4. pub mod game;
5. pub mod obstacles;
7. fn main() -> BError {
8.     // 创建窗口
9.     let ctx = BTermBuilder::simple80x50()
10.         .with_title("Flappy Bird")
11.         .build()
12.         .unwrap();
14.     // 创建游戏内容
15.     let game = game::game::State::new();
17.     // 初始化游戏 loop
18.     main_loop(ctx, game)
19. }

复制代码

game.rs

1. use crate::bird::bird;
2. use crate::obstacles::obstacle;
3. use bracket_lib::{
4.     prelude::{BTerm, GameState},
5.     terminal::{VirtualKeyCode, LIGHT_BLUE},
6. };
7. use std::collections::LinkedList;
9. /// 游戏窗口的宽
10. const GAME_WIDTH: u32 = 80;
11. /// 游戏窗口的高
12. const GAME_HEIGHT: u32 = 50;
13. /// 游戏周期
14. const PERIOD: f32 = 120.0;
16. /// 游戏模式
17. enum GameMode {
18.     /// 游戏中
19.     Playing,
20.     /// 游戏结束
21.     End,
22.     /// 游戏暂停
23.     Paused,
24.     /// 菜单页面
25.     Menu,
26. }
28. /// 游戏 State
29. pub struct State {
30.     /// 当前模式
31.     mode: GameMode,
32.     /// 得分
33.     score: u32,
34.     /// 小鸟
35.     bird: bird::Bird,
36.     /// 等待时间
37.     waite_time: f32,
38.     /// 障碍物列表，因为需要从头尾两处进行操作，所以选择使用双向链表
39.     obstacle_list: LinkedList<obstacle::OBstacle>,
40. }
42. /// bracket_lib::prelude::State 的实现
43. impl GameState for State {
44.     fn tick(&mut self, ctx: &mut BTerm) {
45.         match self.mode {
46.             GameMode::Playing => self.paly_control(ctx),
47.             GameMode::End => self.end_control(ctx),
48.             GameMode::Menu => self.menu_control(ctx),
49.             GameMode::Paused => self.paused_control(ctx),
50.         }
51.     }
52. }
54. impl State {
55.     /// 游戏状态初始化
56.     pub fn new() -> Self {
57.         let mut obstacle_list = LinkedList::new();
58.         obstacle_list.push_back(obstacle::OBstacle::new(0, 35, GAME_HEIGHT));
59.         obstacle_list.push_back(obstacle::OBstacle::new(0, 50, GAME_HEIGHT));
60.         obstacle_list.push_back(obstacle::OBstacle::new(0, 65, GAME_HEIGHT));
61.         obstacle_list.push_back(obstacle::OBstacle::new(0, 80, GAME_HEIGHT));
62.         Self {
63.             mode: GameMode::Menu,
64.             score: 0,
65.             bird: bird::Bird::new(GAME_WIDTH, GAME_HEIGHT),
66.             waite_time: 0.0,
67.             obstacle_list,
68.         }
69.     }
71.     /// 重置游戏内容的方法
72.     fn reset(&mut self) {
73.         self.mode = GameMode::Playing;
74.         self.waite_time = 0.0;
75.         self.bird = bird::Bird::new(GAME_WIDTH, GAME_HEIGHT);
76.         self.score = 0;
77.         let mut obstacle_list = LinkedList::new();
78.         obstacle_list.push_back(obstacle::OBstacle::new(0, 35, GAME_HEIGHT));
79.         obstacle_list.push_back(obstacle::OBstacle::new(0, 50, GAME_HEIGHT));
80.         obstacle_list.push_back(obstacle::OBstacle::new(0, 65, GAME_HEIGHT));
81.         obstacle_list.push_back(obstacle::OBstacle::new(0, 80, GAME_HEIGHT));
82.         self.obstacle_list = obstacle_list;
83.     }
85.     /// 游戏中的控制方法
86.     fn paly_control(&mut self, ctx: &mut BTerm) {
87.         ctx.cls();
88.         ctx.set_bg(GAME_WIDTH, GAME_HEIGHT, LIGHT_BLUE);
90.         // tick 函数的调用周期 ctx.frame_time_ms =33
91.         self.waite_time += ctx.frame_time_ms;
93.         // 达到等待时间了，需要执行游戏内容
94.         if self.waite_time >= PERIOD {
95.             self.bird.gravity_and_move();
96.             self.move_obstacles();
97.             self.pass_obstacles();
98.             self.waite_time = 0.0;
99.         }
101.         if let Some(key) = ctx.key {
102.             match key {
103.                 VirtualKeyCode::P => self.mode = GameMode::Paused,
104.                 VirtualKeyCode::Space => {
105.                     self.bird.flap();
106.                     self.waite_time = 0.0;
107.                 }
108.                 VirtualKeyCode::Q | VirtualKeyCode::Escape => ctx.quit(),
109.                 _ => (),
110.             }
111.         }
112.         self.bird.draw(ctx);
114.         for obt in &self.obstacle_list {
115.             obt.draw(GAME_HEIGHT, ctx)
116.         }
117.         ctx.print(0, 0, format!("Score :{}", self.score));
118.         ctx.print(0, 1, "Space to flap");
119.         ctx.print(0, 2, "(Q/Esc) Quit game)");
121.         if self.bird.bird_out(GAME_HEIGHT) {
122.             self.mode = GameMode::End
123.         }
124.     }
126.     /// 移动障碍物
127.     fn move_obstacles(&mut self) {
128.         for obt in &mut self.obstacle_list {
129.             obt.move_forward(1);
130.         }
131.     }
133.     /// 通过障碍物检测，并记分
134.     fn pass_obstacles(&mut self) {
135.         let first_obt = self.obstacle_list.front().unwrap();
136.         if first_obt.obstacle_x() <= self.bird.bird_x() as u32 {
137.             let half_sie = first_obt.obstacle_size() / 2;
138.             let first_top = first_obt.obstacle_gap_y() - half_sie;
139.             let first_bottom = first_obt.obstacle_gap_y() + half_sie;
140.             let dragon_y = self.bird.bird_y() as u32;
142.             if dragon_y > first_top && dragon_y < first_bottom {
143.                 self.score += 1;
144.             } else {
145.                 self.mode = GameMode::End;
146.             }
148.             self.obstacle_list.pop_front();
149.             self.obstacle_list
150.                 .push_back(obstacle::OBstacle::new(self.score, 80, GAME_HEIGHT));
151.         }
152.     }
154.     /// 游戏结束时的控制方法
155.     fn end_control(&mut self, ctx: &mut BTerm) {
156.         ctx.cls();
157.         ctx.print_centered(6, format!("You are DEAD ! with {} score. ", self.score));
158.         ctx.print_centered(8, " (R)  Restart game");
159.         ctx.print_centered(9, " (Q/Esc) Exit ");
161.         if let Some(key) = ctx.key {
162.             match key {
163.                 VirtualKeyCode::R => {
164.                     self.reset();
165.                     self.mode = GameMode::Playing;
166.                 }
167.                 VirtualKeyCode::Q | VirtualKeyCode::Escape => ctx.quitting = true,
168.                 _ => (),
169.             }
170.         }
171.     }
173.     /// 菜单状态的控制方法
174.     fn menu_control(&mut self, ctx: &mut BTerm) {
175.         ctx.cls();
176.         ctx.print_centered(6, "Welcome to flappy dragon ");
177.         ctx.print_centered(8, " (S) Start game");
178.         ctx.print_centered(9, " (P) Paused game");
179.         ctx.print_centered(10, " (Q/Esc) Exit ");
181.         if let Some(key) = ctx.key {
182.             match key {
183.                 VirtualKeyCode::S => self.mode = GameMode::Playing,
184.                 VirtualKeyCode::Q | VirtualKeyCode::Escape => ctx.quit(),
185.                 _ => (),
186.             }
187.         }
188.     }
190.     /// 游戏暂停时的控制方法
191.     fn paused_control(&mut self, ctx: &mut BTerm) {
192.         ctx.print_centered(0, format!("Score :{}", self.score));
193.         ctx.print_centered(7, "Game Paused, (P) to return game!");
194.         self.bird.draw(ctx);
195.         if let Some(key) = ctx.key {
196.             match key {
197.                 VirtualKeyCode::P => self.mode = GameMode::Playing,
198.                 VirtualKeyCode::Q | VirtualKeyCode::Escape => ctx.quit(),
199.                 _ => (),
200.             }
201.         }
202.     }
203. }

复制代码

bird.rs

1. use bracket_lib::prelude::BTerm;
2. use bracket_lib::terminal::{to_cp437, BLACK, YELLOW_GREEN};
4. /// 小鸟
5. pub struct Bird {
6.     /// x坐标
7.     x: f64,
8.     /// y坐标
9.     y: f64,
10.     /// 下落速度
11.     velocity: f64,
12. }
14. impl Bird {
15.     /// 初始化小鸟
16.     pub fn new(game_width: u32, game_height: u32) -> Self {
17.         Self {
18.             x: (game_width / 5) as f64,
19.             y: (game_height / 2) as f64,
20.             velocity: 0.1,
21.         }
22.     }
24.     /// 绘制
25.     pub fn draw(&self, ctx: &mut BTerm) {
26.         ctx.set(
27.             self.x as u32,
28.             self.y as u32,
29.             YELLOW_GREEN,
30.             BLACK,
31.             to_cp437('&'),
32.         );
33.     }
35.     /// 获取当前的 x 坐标
36.     pub fn bird_x(&self) -> f64 {
37.         self.x
38.     }
40.     /// 获取当前的 y 坐标
41.     pub fn bird_y(&self) -> f64 {
42.         self.y
43.     }
45.     /// 自由下落
46.     pub fn gravity_and_move(&mut self) {
47.         self.velocity += 0.1;
48.         self.y += self.get_velocity();
49.     }
51.     /// 点击空格向上
52.     pub fn flap(&mut self) {
53.         self.y -= 2.0;
54.         self.velocity = 0.1;
55.     }
57.     /// 是否超出边界
58.     pub fn bird_out(&self, max_y: u32) -> bool {
59.         self.y as u32 > max_y || self.y < 0.0
60.     }
62.     /// 获取当前下落的速度，限制到了2.0
63.     fn get_velocity(&mut self) -> f64 {
64.         if self.velocity > 2.0 {
65.             self.velocity = 2.0
66.         }
67.         self.velocity
68.     }
69. }

复制代码

obstacle.rs

1. use bracket_lib::{
2.     prelude::BTerm,
3.     random::RandomNumberGenerator,
4.     terminal::{to_cp437, BLACK, RED},
5. };
7. /// 障碍物
8. pub struct OBstacle {
9.     /// 障碍物的横坐标
10.     x: u32,
11.     /// 缝隙高度
12.     size: u32,
13.     /// 障碍物的中心点
14.     gap_y: u32,
15. }
17. impl OBstacle {
18.     /// 障碍物初始化
19.     ///
20.     /// *score 当前得分
21.     ///
22.     /// *start_x 初始x坐标
23.     ///
24.     /// *screen_height 游戏窗口高度
25.     pub fn new(score: u32, start_x: u32, screen_height: u32) -> Self {
26.         let mut random = RandomNumberGenerator::new();
28.         let size;
29.         if score > 60 {
30.             size = 2
31.         } else {
32.             size = u32::max(2, 20 - score / 3);
33.         }
35.         let half_size = size / 2 + 1;
36.         Self {
37.             x: start_x,
38.             size,
39.             gap_y: random.range(half_size, screen_height - half_size),
40.         }
41.     }
43.     /// 向前移动
44.     ///
45.     /// *distance 向前移动的距离
46.     pub fn move_forward(&mut self, distance: u32) {
47.         self.x -= distance
48.     }
50.     pub fn obstacle_x(&self) -> u32 {
51.         self.x
52.     }
54.     pub fn obstacle_size(&self) -> u32 {
55.         self.size
56.     }
58.     pub fn obstacle_gap_y(&self) -> u32 {
59.         self.gap_y
60.     }
62.     /// 绘制
63.     pub fn draw(&self, screen_height: u32, ctx: &mut BTerm) {
64.         let screen_x = self.x;
65.         let half_size = self.size / 2;
67.         for y in 0..self.gap_y - half_size {
68.             ctx.set(screen_x, y, RED, BLACK, to_cp437('#'));
69.         }
71.         for y in self.gap_y + half_size..screen_height {
72.             ctx.set(screen_x, y, RED, BLACK, to_cp437('#'));
73.         }
74.     }
75. }

复制代码

Cargo.toml

1. [package]
2. name = "flappy_bird"
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. bracket-lib = "0.8.7"

复制代码

Rust官网
Rust 中文社区

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