🛠️ Moonshine 工具

Bevy 工具集合。

特性

Expect<T>

QueryData 的装饰器，如果不匹配则引发恐慌。

这有助于避免由于缺少组件而导致系统中的静默失败

use bevy::prelude::*;
use moonshine_util::expect::Expect;

#[derive(Component)]
struct A;

#[derive(Component)]
struct B;

#[derive(Bundle)]
struct AB {
    a: A, // Every `A` is expected to have a `B`
    b: B,
}

fn bad_system(mut commands: Commands) {
    commands.spawn(A); // BUG: Spawn A witout B!
}

fn unsafe_system(mut query: Query<(&A, &B)>) {
    for (a, b) in query.iter() {
        // An instance of `A` does exist, but this system skips over it silently!
    }
}

fn safe_system(mut query: Query<(&A, Expect<&B>)>) {
    for (a, b) in query.iter() {
        // This system will panic if an `A` instance is missing a `B`!
    }
}

HierarchyQuery

一个方便的 SystemParam，用于遍历和查询实体层次结构

use bevy::prelude::*;
use moonshine_util::hierarchy::HierarchyQuery;

#[derive(Component)]
struct Needle;

#[derive(Component)]
struct Haystack;

fn spawn_haystack(mut commands: Commands) {
    // A complex hierarchy ...
    commands.spawn(Haystack).with_children(|x| {
        x.spawn_empty().with_children(|y| {
            y.spawn_empty().with_children(|z| {
                z.spawn(Needle);
            });
        });
    });
}

fn find_needle(
    haystack: Query<Entity, With<Haystack>>,
    needle_query: Query<Entity, With<Needle>>,
    hierarchy: HierarchyQuery
) {
    let haystack = haystack.single();
    if let Some(needle) = hierarchy.find_descendant(haystack, &needle_query) {
        // ...
    }
}

一些有用的函数包括

• fn parent(&self, Entity) -> Option<Entity>
• fn has_parent(&self, Entity) -> bool
• fn children(&self, Entity) -> Iterator<Item = Entity>
• fn has_children(&self, Entity) -> bool
• fn root(&self, Entity) ->Entity
• fn is_root(&self, Entity) -> bool
• fn ancestors(&self, Entity) -> Iterator<Item = Entity>
• fn descendants(&self, Entity) -> Iterator<Item = Entity>
• fn is_ancestor_of(&self, Entity, Entity) -> bool
• fn is_descendant_of(&self, Entity, Entity) -> bool
• fn find_ancestor<T, F>(&self, Entity,&Query<T, F>) -> Option<QueryItem<T>>
• fn find_descendant<T, F>(&self, Entity,&Query<T, F>) -> Option<QueryItem<T>>

请参阅代码文档以获取完整详细信息。

RunSystemLoop

类似于 RunSystemOnce 的特质，允许您为测试目的运行系统循环

use bevy::prelude::*;
use moonshine_util::diagnostics::RunSystemLoop;

let mut world = World::new();
let outputs = world.run_system_loop(2, |mut commands: Commands| {
    commands.spawn_empty().id()
});

assert_eq!(outputs.len(), 2);

assert!(world.get_entity(outputs[0]).is_some());
assert!(world.get_entity(outputs[1]).is_some());

实用系统

一组简单且通用的系统，可用于构建更大的系统管道

• has_event<T:Event>() -> bool
• has_resource<T:Resource>() -> bool
• remove_resource<T:Resource>(Commands)
• remove_resource_immediate<T:Resource>(&mutWorld)

请参阅代码文档以获取用法示例。

支持

请提交问题，任何错误、问题或建议。

您也可以在官方Bevy Discord服务器上联系我，ID为 @Zeenobit。