Hands-on Rust 学习之旅(4) ——小鸟飞起来了

叶梅树
3,488 阅读3分钟

在继续上一篇的游戏开发之前，我们来看看成品效果:

fly

主要增加了三个角色：

  1. '@'字符充当小鸟，负责上下移动，来躲避迎面而来的障碍物——墙壁；
  2. 就是我们的障碍物，障碍物随着时间从屏幕右侧不断左移；
  3. 还有就是得分，只要小鸟穿过障碍物，即得一分；如果没躲过，则，游戏 Game Over。

Adding the Player

'@'字符充当小鸟

小鸟的作用在于需要上下移动，正常情况下处于“自由落地”状态，当我们点击空格键，让它飞起来，不至于落下。

跟之前一样，用一个 struct 结构体来表示 Player，主要是坐标位置和上下移动的加速度变化值:

struct Player {
    x: i32,
    y: i32,
    velocity: f32,
}

首先定一个@字符显示效果：

impl Player {
    fn new(x: i32, y: i32) -> Self {
        Player {
            x,
            y,
            velocity: 0.0,
        }
    }

    fn render(&mut self, ctx: &mut BTerm) {
        ctx.set(
            0,
            self.y,
            YELLOW,
            BLACK,
            to_cp437('@')
        );
    }
}

这个比较好理解，在之后的代码过程中，去重点解释bracket-lib 引擎。

接下来就是定义两个动作，主要是加速度的变化问题，相信看代码能懂：

fn gravity_and_move(&mut self) {
    if self.velocity < 2.0 {
        self.velocity += 0.2;
    }
    self.y += self.velocity as i32;
    self.x += 1;
    
    if self.y < 0 {
        self.y = 0;
    }
}

fn flap(&mut self) {
    self.velocity = -2.0;
}

Creating Obstacles

创建障碍

障碍物，主要考虑的是缺口的随机出现和缺口得大小。

struct Obstacle {
    x: i32,
    gap_y: i32,
    size: i32,
}

本文中，缺口的大小和得分有关，随着得分的越多，缺口越小，这也是游戏的难度不断增加，具体看 new 函数：

impl Obstacle {
    fn new(x: i32, score: i32) -> Self {
        let mut random = RandomNumberGenerator::new();
        Obstacle {
            x,
            gap_y: random.range(10, 40),
            size: i32::max(2, 20 -score)
        }
    }

    fn render(&mut self, ctx: &mut BTerm, player_x: i32) {
        let screen_x = self.x - player_x;
        let half_size = self.size / 2;

        for y in 0..self.gap_y - half_size {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }

        for y in self.gap_y + half_size..SCREEN_HEIGHT {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }
    }
}

墙体的设计，主要以缺口大小分成两段来控制 y 坐标，以自己的 x 坐标和小鸟的坐标确定每一祯 x 值，实现不断靠近小鸟的效果。

还需要增加一个小鸟和障碍物碰到的逻辑：

fn hit_obstacle(&self, player: &Player) -> bool {
    let half_size = self.size / 2;
    let does_x_match = player.x == self.x;
    let player_above_gap = player.y < self.gap_y - half_size;
    let player_below_gap = player.y > self.gap_y + half_size;
    
    does_x_match && (player_above_gap || player_below_gap)
}

这代码好理解，就不解释了。

Keeping Score

得分逻辑

得分逻辑就比较简单了，只要小鸟的 x 坐标 > 障碍物的 x 坐标，表示小鸟“飞过”障碍物，并且小鸟没碰上障碍物，则得分+1，并且重置新的障碍物：

fn play(&mut self, ctx: &mut BTerm) {
    // TODO: Fill in this stub later
    ctx.cls_bg(NAVY);
    self.frame_time += ctx.frame_time_ms;
    
    if self.frame_time > FRAME_DURATION {
        self.frame_time = 0.0;
        self.player.gravity_and_move();
    }

    if let Some(VirtualKeyCode::Space) = ctx.key {
        self.player.flap();
    }
    self.player.render(ctx);
    ctx.print(0, 0, "按住空格保持飞翔");
    ctx.print(0, 1, &format!("得分：{}", self.score));

    self.obstacle.render(ctx, self.player.x);
    if self.player.x > self.obstacle.x {
        self.score += 1;
        self.obstacle = Obstacle::new(self.player.x + SCREEN_WIDTH, self.score);
    }

    if self.player.y > SCREEN_HEIGHT || self.obstacle.hit_obstacle(&self.player) {
        self.mode = GameMode::End;
    }
}

其他的参数都是辅助于逻辑的完成，下面我把整个代码贴出来，大家看看也就懂了：

use bracket_lib::prelude::*;

const SCREEN_WIDTH: i32 = 80;
const SCREEN_HEIGHT: i32 = 50;
const FRAME_DURATION: f32 = 75.0;
struct Player {
    x: i32,
    y: i32,
    velocity: f32,
}

impl Player {
    fn new(x: i32, y: i32) -> Self {
        Player {
            x,
            y,
            velocity: 0.0,
        }
    }

    fn render(&mut self, ctx: &mut BTerm) {
        ctx.set(
            0,
            self.y,
            YELLOW,
            BLACK,
            to_cp437('@')
        );
    }

    fn gravity_and_move(&mut self) {
        if self.velocity < 2.0 {
            self.velocity += 0.2;
        }
        self.y += self.velocity as i32;
        self.x += 1;
        
        if self.y < 0 {
            self.y = 0;
        }
    }

    fn flap(&mut self) {
        self.velocity = -2.0;
    }
}

struct Obstacle {
    x: i32,
    gap_y: i32,
    size: i32,
}

impl Obstacle {
    fn new(x: i32, score: i32) -> Self {
        let mut random = RandomNumberGenerator::new();
        Obstacle {
            x,
            gap_y: random.range(10, 40),
            size: i32::max(2, 20 -score)
        }
    }

    fn render(&mut self, ctx: &mut BTerm, player_x: i32) {
        let screen_x = self.x - player_x;
        let half_size = self.size / 2;

        for y in 0..self.gap_y - half_size {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }

        for y in self.gap_y + half_size..SCREEN_HEIGHT {
            ctx.set(
                screen_x,
                y,
                RED,
                BLACK,
                to_cp437('/'),
            );
        }
    }

    fn hit_obstacle(&self, player: &Player) -> bool {
        let half_size = self.size / 2;
        let does_x_match = player.x == self.x;
        let player_above_gap = player.y < self.gap_y - half_size;
        let player_below_gap = player.y > self.gap_y + half_size;
        
        does_x_match && (player_above_gap || player_below_gap)
    }
}

enum GameMode {
    Menu,
    Playing,
    End,
}

struct State {
    player: Player,
    frame_time: f32,
    obstacle: Obstacle,
    mode: GameMode,
    score: i32,
}

impl State {
    fn new() -> Self {
        State {
            player: Player::new(5, 25),
            frame_time: 0.0,
            obstacle: Obstacle::new(SCREEN_WIDTH, 0),
            mode: GameMode::Menu,
            score: 0,
        }
    }

    fn restart(&mut self) {
        self.player = Player::new(5, 25);
        self.frame_time = 0.0;
        self.mode = GameMode::Playing;
    }

    fn main_menu(&mut self, ctx: &mut BTerm) {
        ctx.cls();
        ctx.print_centered(5, "Welcome to Flappy Dragon");
        ctx.print_centered(8, "(P) Play Game");
        ctx.print_centered(9, "(Q) Quit Game");

        if let Some(key) = ctx.key {
            match key {
                VirtualKeyCode::P => self.restart(),
                VirtualKeyCode::Q => ctx.quitting = true,
                _ => {}
            }
        }
        self.player = Player::new(5, 25);
        self.frame_time = 0.0;
        self.obstacle = Obstacle::new(SCREEN_WIDTH, 0);
        self.mode = GameMode::Playing;
        self.score = 0;
    }

    fn dead(&mut self, ctx: &mut BTerm) {
        ctx.cls();
        ctx.print_centered(5, "You are dead!");
        ctx.print_centered(6, &format!("You earned {} points", self.score));
        ctx.print_centered(8, "(P) Play Again");
        ctx.print_centered(9, "(Q) Quit Game");

        if let Some(key) = ctx.key {
            match key {
                VirtualKeyCode::P => self.restart(),
                VirtualKeyCode::Q => ctx.quitting = true,
                _ => {}
            }
        }
    }

    fn play(&mut self, ctx: &mut BTerm) {
        // TODO: Fill in this stub later
        ctx.cls_bg(NAVY);
        self.frame_time += ctx.frame_time_ms;
        
        if self.frame_time > FRAME_DURATION {
            self.frame_time = 0.0;
            self.player.gravity_and_move();
        }

        if let Some(VirtualKeyCode::Space) = ctx.key {
            self.player.flap();
        }
        self.player.render(ctx);
        ctx.print(0, 0, "按住空格保持飞翔");
        ctx.print(0, 1, &format!("得分：{}", self.score));

        self.obstacle.render(ctx, self.player.x);
        if self.player.x > self.obstacle.x {
            self.score += 1;
            self.obstacle = Obstacle::new(self.player.x + SCREEN_WIDTH, self.score);
        }

        if self.player.y > SCREEN_HEIGHT || self.obstacle.hit_obstacle(&self.player) {
            self.mode = GameMode::End;
        }
    }
}

impl GameState for State {
    fn tick(&mut self, ctx: &mut BTerm) {
        // ctx.cls();
        // ctx.print(1, 1, "Hello, Bracket Terminal!");
        match self.mode {
            GameMode::Menu => self.main_menu(ctx),
            GameMode::End => self.dead(ctx),
            GameMode::Playing => self.play(ctx),
        }
    }
}

fn main() ->BError {
    println!("Hello, world!");

    let context = BTermBuilder::simple80x50()
        .with_title("Flappy Dragon")
        .build()?;
    
    main_loop(context, State::new())
}

整个运行效果，就是开篇的那样：

fly

avatar
文章
阅读
粉丝
相关推荐
Hands-on Rust 学习之旅(1)——Rust 环境安装
4.4k阅读
 · 
9点赞
Hands-on Rust 学习之旅(2)—— 基础知识
3.7k阅读
 · 
3点赞
Hands-on Rust 学习之旅(5)—— Modules 学习
1.9k阅读
 · 
2点赞
Hands-on Rust 学习之旅(3)—— 游戏基本流程
2.7k阅读
 · 
2点赞
扔掉 Electron，拥抱基于 Rust 开发的 Tauri
118k阅读
 · 
613点赞