Rust

Question

我是一名使用 Rust 语言的初级开发人员。我来自 JavaScript，很多功能和特性对我来说仍然不清楚。

目前，我正在寻找用 Rust 构建自己的 ECS（实体组件系统）系统。当我想从实体中获取组件时，我一直卡住了。

实际上我使用动态盒装向量将组件存储在实体中，这是一个好方法吗？

我的代码：

enum ComponentEnum {
    Position,
    Size
}

trait Component {}

// Position Component
#[derive(PartialEq, PartialOrd, Debug)]
struct Position {
    x: i32,
    y: i32
}

// Size Component
#[derive(PartialEq, PartialOrd, Debug)]
struct Size {
    height: i32,
    width: i32
}

impl Component for Position {}
impl Component for Size {}

struct Entity {
    id: usize,
    components: Vec<Box<dyn Component>>
}

impl Entity {
    fn new(index: usize) -> Self {
        Entity { id: index, components: vec![] }
    }

    // Add a component in Entity
    fn add_component<T: 'static + Component>(&mut self, component: T) {
        self.components.push(Box::new(component));
    }
}

struct EntityStore {
    entities: Vec<Entity>,
    current_index: usize,
}
impl EntityStore {
    fn new() -> EntityStore {
        EntityStore { entities: vec![], current_index: 0 }
    }

    fn generate_index(&self) -> usize {
        unimplemented!();
    }

    // Stop creation system and update EntityStore current_index
    fn end(&mut self) -> &mut Entity {
        let entity = self.entities.get_mut(self.current_index).unwrap();
        self.current_index = self.current_index + 1;
        entity
    }

    fn create_entity(&mut self) -> &mut Self {
        let mut entity = Entity::new(self.current_index);
        self.entities.push(entity);

        self
    }

    // Add component to entity
    fn with_component<T: 'static + Component>(&mut self, component: T) ->  &mut Self {
        let mut entity = self.entities.get_mut(self.current_index).unwrap();
        entity.add_component(component);

        self
    }
}

fn main() {
    let mut es = EntityStore::new();

    // Make entity
    let mut entity1 = es
        .create_entity()
        .with_component(Position { x: 0, y: 0 })
        .with_component(Size { height: 10, width: 10 })
        .end();

    // Get entity position component
    // let component_position_entity1 = entity1.get_component(ComponentEnum::Position);
}

如何从我的实体取回我的 Position 组件？

编辑：

这里，一个获取组件的测试函数（在实体实现中）：

fn get_component(&mut self, component_enum: ComponentEnum) { //want return Position or Size component
        let mut entity_components = &self.components;

        // Search component by Name ?
        // Currently, i try to compare Component trait with Component Enum element...
        let component = entity_components
            .iter_mut()
            .find(|component| component == component_enum)
            .unwrap();

        // Here, the component type is "&mut Box<dyn Component>" but i want type like "&mut Position" or "&mut Size"

        component // Here i need to return a Position or Size struct component, but i have Component Trait so i can't use Position/Size functions
}

谢谢。

Answer 1

我会使用枚举来区分组件类型（请记住，我对 ECS 系统的总体经验很少）。然后你有多种方法来获得一种类型，但我已经制作了一个方法 get_component，它在找到正确的组件时需要一个闭包。然后，您可以向它传递一个专门检查位置组件的闭包。

这是我的实现，基于您的示例：


// Position Component
#[derive(PartialEq, PartialOrd, Debug)]
struct Position {
    x: i32,
    y: i32
}

// Size Component
#[derive(PartialEq, PartialOrd, Debug)]
struct Size {
    height: i32,
    width: i32
}

#[derive(PartialEq, PartialOrd, Debug)]
enum Component {
    Position(Position),
    Size(Size)
}

struct Entity {
    id: usize,
    components: Vec<Component>
}

impl Entity {
    fn new(index: usize) -> Self {
        Entity { id: index, components: vec![] }
    }

    // Add a component in Entity
    fn add_component(&mut self, component: Component) {
        self.components.push(component);
    }
    
    fn get_component(&self, pred: impl Fn(&&Component) -> bool) -> Option<&Component>{
        self.components.iter().find(pred)
    }
    
}

struct EntityStore {
    entities: Vec<Entity>,
    current_index: usize,
}
impl EntityStore {
    fn new() -> EntityStore {
        EntityStore { entities: vec![], current_index: 0 }
    }

    fn generate_index(&self) -> usize {
        unimplemented!();
    }

    // Stop creation system and update EntityStore current_index
    fn end(&mut self) -> &mut Entity {
        let entity = self.entities.get_mut(self.current_index).unwrap();
        self.current_index = self.current_index + 1;
        entity
    }

    fn create_entity(&mut self) -> &mut Self {
        let mut entity = Entity::new(self.current_index);
        self.entities.push(entity);

        self
    }

    // Add component to entity
    fn with_component(&mut self, component: Component) ->  &mut Self {
        let mut entity = self.entities.get_mut(self.current_index).unwrap();
        entity.add_component(component);

        self
    }
}

fn main() {
    let mut es = EntityStore::new();

    // Make entity
    let mut entity1 = es
        .create_entity()
        .with_component(Component::Position(Position { x: 0, y: 0 }))
        .with_component(Component::Size(Size { height: 10, width: 10 }))
        .end();

    // Get entity position component
    let component_position_entity1 = entity1.get_component(|c| if let Component::Position(_) = c { true} else {false});
    println!("{:?}", component_position_entity1);
}

请注意，我的 get_component 有很多替代方案，但我的主要观点是使用枚举来区分组件类型，而不是使用 Box<dyn Component>。

Answer 2

@user4815162342 在评论中发布了这个以直接索引到 entity.components：

像这样：

    fn main() {
        let mut es = EntityStore::new();
    
        // Make entity
        let mut entity1 = es
            .create_entity()
            .with_component(Position { x: 0, y: 0 })
            .with_component(Size { height: 10, width: 10 })
            .end();
    
        // Get entity position component
        let v0 = &entity1.components[0];
        let v1 = &entity1.components[1];
        v0.display();
        v1.display();
    }

但由于索引取决于实体的添加顺序，因此最好将实体组件存储在哈希映射中，或者使用 enum 标记以使其更清楚每个组件都是。

Rust - 在 Vec<Box dyn ComponentTrait>> (ECS) 中获取组件

Rust - Get component in Vec<Box dyn ComponentTrait>> (ECS)

entity-component-system