Roguelike In Rust 05: 生成地牢

这一节我们将会创建一个地牢，地牢由不同的房间组成，房间与房间之间是联通的，玩家可以行走。下面是最终运行效果图。

工程代码接着上一节的内容。随着代码越来越多，我们需要将逻辑代码分割到不同的代码文件中。

首先将地图描述及生成相关的代码，放到一个独立的文件中，新建一个名为 map.rs 的文件，将 main.rs 中的 TileType，xy_idx()，new_map 函数，这三部分的代码，剪到 map.rs 中。并将 new_map 函数名字改为 new_map_test。代码如下

use rltk::RandomNumberGenerator;

use super::Rect;
use std::cmp::{max, min};

#[derive(PartialEq, Copy, Clone)]
pub enum TileType {
    Wall, Floor
}

pub fn xy_idx(x: i32, y: i32) -> usize {
    (y as usize * 80) + x as usize
}

/// Makes a map with solid boundaries and 400 randomly placed walls.
/// No guarantees that it won't look awful.
pub fn new_map_test() -> Vec<TileType> {
    let mut map = vec![TileType::Floor; 80*50];
    // 下面和上面的墙
    for x in 0..80 {
        map[xy_idx(x, 0)] = TileType::Wall;
        map[xy_idx(x, 49)] = TileType::Wall;
    }

    // 左边和右边的墙
    for y in 0..50 {
        map[xy_idx(0, y)] = TileType::Wall;
        map[xy_idx(79, y)] = TileType::Wall;
    }

    let mut rng = rltk::RandomNumberGenerator::new();
    for _i in 0..400 {
        let x = rng.roll_dice(1, 79);
        let y = rng.roll_dice(1, 49);
        let idx = xy_idx(x, y);

        // 地图的中心不能为墙，因为角色出生在那里
        if idx != xy_idx(40, 25) {
            map[idx] = TileType::Wall;
        }
    }

    map
}

在 map.rs 中添加一个新的函数，用来生成房间和走廊。

pub fn new_map_rooms_and_corridors() -> Vec<TileType> {
    let mut map = vec![TileType::Wall; 80*50];

    map
}

为了更方便的进行计算，我们还需要创建一个 Rect 结构体，用来描述坐标位置。新建一个名为 rect.rs 的文件，代码如下

pub struct Rect {
    pub x1 : i32,   // x 起始
    pub x2 : i32,   // x 结束
    pub y1 : i32,   // y 起始
    pub y2 : i32,   // y 结束
}

impl Rect {
    pub fn new(x:i32, y: i32, w:i32, h:i32) -> Rect {
        Rect{x1:x, y1:y, x2:x+w, y2:y+h}
    }

    // Returns true if this overlaps with other
    pub fn intersect(&self, other:&Rect) -> bool {
        self.x1 <= other.x2 && self.x2 >= other.x1 && self.y1 <= other.y2 && self.y2 >= other.y1
    }

    pub fn center(&self) -> (i32, i32) {
        ((self.x1 + self.x2)/2, (self.y1 + self.y2)/2)
    }
}

现在回到 map.rs 代码文件，添加一个函数 apply_room_to_map 的函数，用来在地图上设置房间。

fn apply_room_to_map(room : &Rect, map: &mut [TileType]) {
    for y in room.y1 +1 ..= room.y2 {
        for x in room.x1 + 1 ..= room.x2 {
            map[xy_idx(x, y)] = TileType::Floor;
        }
    }
}

现在我们在 new_map_rooms_and_corridors 这个地图生成函数中，添加两个房间，来测试一下我们的逻辑

pub fn new_map_rooms_and_corridors() -> Vec<TileType> {
    let mut map = vec![TileType::Wall; 80*50];

    let room1 = Rect::new(20, 15, 10, 15);
    let room2 = Rect::new(35, 15, 10, 15);

    apply_room_to_map(&room1, &mut map);
    apply_room_to_map(&room2, &mut map);

    map
}

为了能够运行，我们需要修改一下 main.rs 中的函数调用，首先在最上面，添加两个文件的引用，并且将原来调用 new_map 的地方，修改为调用 new_map_rooms_and_corridors

// main.rs
mod map;
pub use map::*;
mod rect;
pub use rect::Rect;

然后运行 cargo run，将得到现在的结果

接下来我们要做的，是生成走廊，来连接两个房间。在 map.rs 中添加走廊生成函数，走廊有横向的，和纵向的。

fn apply_horizontal_tunnel(map: &mut [TileType], x1:i32, x2:i32, y:i32) {
    for x in min(x1,x2) ..= max(x1,x2) {
        let idx = xy_idx(x, y);
        if idx > 0 && idx < 80*50 {
            map[idx as usize] = TileType::Floor;
        }
    }
}

fn apply_vertical_tunnel(map: &mut [TileType], y1:i32, y2:i32, x:i32) {
    for y in min(y1,y2) ..= max(y1,y2) {
        let idx = xy_idx(x, y);
        if idx > 0 && idx < 80*50 {
            map[idx as usize] = TileType::Floor;
        }
    }
}

然后运行 cargo run 将得到下面的结果

接下来我们来生成地牢，地牢是有多个相连的房间构成，首先要做的就是生成多个房间。修改 new_map_rooms_and_corridors 函数，首先定义最大的房间数量，以及房间的最大和最小值。然后跑个循环，进行生成，如果生成的房间没有与已生成的房间重叠，则视为合法的，否则，直接丢弃。

pub fn new_map_rooms_and_corridors() -> Vec<TileType> {
    let mut map = vec![TileType::Wall; 80*50];

    let mut rooms : Vec<Rect> = Vec::new();
    const MAX_ROOMS : i32 = 30;
    const MIN_SIZE : i32 = 6;
    const MAX_SIZE : i32 = 10;

    let mut rng = RandomNumberGenerator::new();

    for _ in 0..MAX_ROOMS {
        let w = rng.range(MIN_SIZE, MAX_SIZE);
        let h = rng.range(MIN_SIZE, MAX_SIZE);
        let x = rng.roll_dice(1, 80 - w - 1) - 1;
        let y = rng.roll_dice(1, 50 - h - 1) - 1;
        let new_room = Rect::new(x, y, w, h);
        let mut ok = true;
        for other_room in rooms.iter() {
            if new_room.intersect(other_room) { ok = false }
        }
        if ok {
            apply_room_to_map(&new_room, &mut map);        
            rooms.push(new_room);            
        }
    }

    map
}

然后运行 cargo run 将得到下面的结果

接下来就是将生成的多个房间进行连接，如何连接呢？就是每当一个新的房间产生时，将它与上一个房间进行连接，即可。还是修改 new_map_rooms_and_corridors 函数中的 if ok 那一段

if ok {
    apply_room_to_map(&new_room, &mut map);

    if !rooms.is_empty() {
        let (new_x, new_y) = new_room.center();
        let (prev_x, prev_y) = rooms[rooms.len()-1].center();
        if rng.range(0,2) == 1 {
            apply_horizontal_tunnel(&mut map, prev_x, new_x, prev_y);
            apply_vertical_tunnel(&mut map, prev_y, new_y, new_x);
        } else {
            apply_vertical_tunnel(&mut map, prev_y, new_y, prev_x);
            apply_horizontal_tunnel(&mut map, prev_x, new_x, new_y);
        }
    }

    rooms.push(new_room);
}

然后运行 cargo run 将得到下面的结果

现在，整个地牢已经生成好了，下面还需要将玩家放在正确的位置，在修改之前，玩家可能出现在墙里。为了将玩家放在正确的位置，main 函数就需要知道所有生成的房间，所以我们将 new_map_rooms_and_corridors 函数的返回值，修改为 pub fn new_map_rooms_and_corridors() -> (Vec<Rect>, Vec<TileType>)，也就是将生成的房间数据，也返回，这样 main 函数就可以使用第一个房间的位置数据，并且将玩家放在第一个房间内。

fn main() -> rltk::BError {
    use rltk::RltkBuilder;
    let context = RltkBuilder::simple80x50()
        .with_title("Roguelike Tutorial")
        .build()?;
    let mut gs = State {
        ecs: World::new()
    };
    gs.ecs.register::<Position>();
    gs.ecs.register::<Renderable>();
    gs.ecs.register::<Player>();

    // 将玩家放在第一个房间内
    let (rooms, map) = new_map_rooms_and_corridors();
    gs.ecs.insert(map);
    let (player_x, player_y) = rooms[0].center();

    gs.ecs
        .create_entity()
        .with(Position { x: player_x, y: player_y })
        .with(Renderable {
            glyph: rltk::to_cp437('@'),
            fg: RGB::named(rltk::YELLOW),
            bg: RGB::named(rltk::BLACK),
        })
        .with(Player{})
        .build();

    rltk::main_loop(context, gs)
}

到此为止，基本上OK了，不过我们再修改一点东西，添加 VIM 的键位控制，也就是可以使用 H、L、K、J，以及小键盘，来控制玩家的移动，这个很简单，只需要修改 player_input 函数即可

pub fn player_input(gs: &mut State, ctx: &mut Rltk) {
    // Player movement
    match ctx.key {
        None => {} // Nothing happened
        Some(key) => match key {
            VirtualKeyCode::Left |
            VirtualKeyCode::Numpad4 |
            VirtualKeyCode::H => try_move_player(-1, 0, &mut gs.ecs),

            VirtualKeyCode::Right |
            VirtualKeyCode::Numpad6 |
            VirtualKeyCode::L => try_move_player(1, 0, &mut gs.ecs),

            VirtualKeyCode::Up |
            VirtualKeyCode::Numpad8 |
            VirtualKeyCode::K => try_move_player(0, -1, &mut gs.ecs),

            VirtualKeyCode::Down |
            VirtualKeyCode::Numpad2 |
            VirtualKeyCode::J => try_move_player(0, 1, &mut gs.ecs),

            _ => {}
        },
    }
}

好了，一切已经做完了，使用 cargo run 运行体验一下吧。

本篇所有代码 https://github.com/moeif/roguelike-rs/tree/05

猫语互动

欢迎关注微信公众号 猫语互动，博客文章同步推送

猫语互动#

猫语互动