bevy_entity_graph 0.2.0

Create graphs of entities in the Bevy game engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use bevy::{
    app::{App, FixedUpdate, Plugin},
    ecs::{
        entity::Entity,
        message::{Message, MessageReader, MessageWriter},
        schedule::{
            InternedSystemSet, IntoScheduleConfigs, ScheduleConfigs, SystemSet,
            common_conditions::on_message,
        },
        system::Query,
    },
    log::warn,
};

pub use crate::{
    connected_components::{ConnectedComponent, InConnectedComponent},
    connections::{ConnectionUpdateEvent, Connections},
};

mod connected_components;
mod connections;

pub struct EntityGraphPlugin;
impl Plugin for EntityGraphPlugin {
    fn build(&self, app: &mut App) {
        app.add_message::<ConnectMessage>()
            .add_message::<DisconnectMessage>()
            .configure_sets(FixedUpdate, EntityGraphSystem::get_config())
            .add_systems(
                FixedUpdate,
                (
                    ConnectMessage::on_message.run_if(on_message::<ConnectMessage>),
                    DisconnectMessage::on_message.run_if(on_message::<DisconnectMessage>),
                )
                    .chain()
                    .in_set(EntityGraphSystem::UpdateGraph),
            )
            .add_plugins((
                connected_components::ConnectedComponentPlugin,
                connections::ConnectionsPlugin,
            ));
    }
}

/// Set enum for the systems relating to transform propagation
#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
pub enum EntityGraphSystem {
    UpdateGraph,
    ComputeConnectedComponents,
}
impl EntityGraphSystem {
    fn get_config() -> ScheduleConfigs<InternedSystemSet> {
        (Self::UpdateGraph, Self::ComputeConnectedComponents).chain()
    }
}

#[derive(Message, Debug)]
pub struct ConnectMessage(pub (Entity, Entity));
impl ConnectMessage {
    fn on_message(
        mut events: MessageReader<ConnectMessage>,
        mut updates: MessageWriter<ConnectionUpdateEvent>,
        mut query: Query<&mut Connections>,
    ) {
        for &ConnectMessage((entity1, entity2)) in events.read() {
            if let Ok(mut connections) = query.get_mut(entity1) {
                connections.connect(entity2);
                updates.write(ConnectionUpdateEvent(entity1));
            } else {
                warn!("Entity {entity1} did not exist");
            }
            if let Ok(mut connections) = query.get_mut(entity2) {
                connections.connect(entity1);
                updates.write(ConnectionUpdateEvent(entity2));
            } else {
                warn!("Entity {entity2} did not exist");
            }
        }
    }
}

#[derive(Message, Debug)]
pub struct DisconnectMessage(pub (Entity, Entity));
impl DisconnectMessage {
    fn on_message(
        mut events: MessageReader<DisconnectMessage>,
        mut updates: MessageWriter<ConnectionUpdateEvent>,
        mut query: Query<&mut Connections>,
    ) {
        for &DisconnectMessage((entity1, entity2)) in events.read() {
            if let Ok(mut connections) = query.get_mut(entity1) {
                connections.disconnect(entity2);
                updates.write(ConnectionUpdateEvent(entity1));
            }
            if let Ok(mut connections) = query.get_mut(entity2) {
                connections.disconnect(entity1);
                updates.write(ConnectionUpdateEvent(entity2));
            }
        }
    }
}