Nate-Engine

描述

Nate-Engine是一个我在无聊时进行的实验性项目。主要概念是Nate-Engine是一个基于实体组件系统(ECS)模型的游戏引擎。我可能会用它来制作一些tui游戏或类似的东西，但我强烈建议不要将其用于其他项目，因为它纯粹是一个测试，大多数真实项目可能应该使用像bevy这样的工具。

目标

项目的目标是使ECS系统的创建通过几个宏变得非常简单，如下所示

组件

组件宏应该使项目中的组件列表定义变得简单。可能还需要有用于每个实体而不重复的单个项。可能如下所示

#[world(singular=[canvas])]
pub struct World {
    position: (f32, f32),
    player_velocity: (f32, f32),
    object_velocity: (f32, f32),
    sprite: Sprite,
    canvas: [[bool; 10]; 10],
}

这可以翻译为

pub struct World {
    entities: Arc<RwLock<Vec<u32>>>,

    pub canvas: Arc<RwLock<Option<[[bool; 10]; 10]>>>,

    pub position: Arc<RwLock<Vec<Option<(f32, f32)>>>>,
    pub player_velocity: Arc<RwLock<Vec<Option<(f32, f32)>>>>,
    pub object_velocity: Arc<RwLock<Vec<Option<(f32, f32)>>>>,
    pub sprite: Arc<RwLock<Vec<Option<Sprite>>>>,
}

系统

对于系统，我希望自动生成迭代器+过滤器，这样在proc-macro中，用户只需指定应存在的字段，以及可选的过滤器参数。例如

#[system(world=DinosaurWorld, read=[object_velocity], write=position)]
fn position_update_system() {
    *position = (position.0 + object_velocity.0, position.1 + object_velocity.1);
}

这会扩展为

fn position_update_system(world: Arc<DinosaurWorld>) {
    let object_velocity = world.object_velocity.read().unwrap();
    let mut position = world.positions.write().unwrap();
    for (object_velocity, position) in object_velocity.iter().zip(position.iter_mut()).filter(|v| v.0.is_some() && v.1.is_some()) {
        let object_velocity = object_velocity.as_ref().unwrap();
        let mut position = position.as_mut().unwrap();

        position = (position.0 + object_velocity.0, position.1 + object_velocity.1);
    }
}

这也可能非常有用，添加某种类型的过滤器，允许用户过滤不仅存在某个组件，而且该组件具有某些值。例如以下情况

#[world]
pub struct World {
    position: (u32, u32),
    damage_zone: (u32, u32),
    health: u32,
}

#[system(
    world=World,
    write=[health],
    read=[position, damage_zone],
    filter="position == damage_zone"
)]
fn position_damage_system() {
    health -= 1;
}

这会扩展为

pub struct World {
    entities: Arc<RwLock<Vec<u32>>>,

    positions: Arc<RwLock<Vec<Option<(u32, u32)>>>>,
    damage_zones: Arc<RwLock<Vec<Option<(u32, u32)>>>>,
    healths: Arc<RwLock<Vec<Option<u32>>>>,
}

fn position_damage_system(world: Arc<World>) {
    let positions = world.positions.read().unwrap();
    let damage_zones = world.damage_zones.read().unwrap();
    let mut healths = world.healths.write().unwrap();
    for ((_position, _damage_zone), health) in positions.iter().zip(damage_zones.iter()).zip(healths.iter_mut()).filter(|v| v.0.0.is_some() && v.0.1.is_some() && v.1.is_some() && v.0.0 == v.0.1) {
        *health -= 1
    }
}

也可以通过使用_read和_write作为其标识符来在系统中引用单个组件。例如

#[system(world=World, _read=[canvas], _write=[exit])]
fn read_canvas_and_exit() {
    ...
}

这将允许用户通过读取访问canvas，并写入exit