bevy_diesel 0.1.0

A generic ability engine framework for Bevy
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use bevy::prelude::*;
use bevy_gearbox::prelude::*;
use bevy_gearbox::transitions::TransitionEvent;

use crate::invoker::InvokedBy;

// ---------------------------------------------------------------------------
// Repeater component
// ---------------------------------------------------------------------------

/// Counter-driven repetition. Place on a state entity.
#[derive(Component, Clone, Debug, Reflect, Default)]
#[reflect(Component, Default)]
pub struct Repeater {
    pub remaining: u32,
    pub initial: u32,
}

impl Repeater {
    pub fn new(count: u32) -> Self {
        Self {
            remaining: count,
            initial: count,
        }
    }
}

// ---------------------------------------------------------------------------
// OnComplete event
// ---------------------------------------------------------------------------

/// Fired when a repeater's counter reaches zero.
#[derive(SimpleTransition, EntityEvent, Debug, Clone, Reflect)]
pub struct OnComplete {
    #[event_target]
    pub entity: Entity,
}

impl OnComplete {
    pub fn new(entity: Entity) -> Self {
        Self { entity }
    }
}

// ---------------------------------------------------------------------------
// Repeater observer
// ---------------------------------------------------------------------------

/// Trait for events that the repeater can emit on each tick.
pub trait Repeatable: EntityEvent + TransitionEvent + Send + Sync + 'static
where
    for<'a> <Self as Event>::Trigger<'a>: Default,
{
    fn repeat_tick(entity: Entity) -> Self;
}

pub fn repeater_observer<E: Repeatable>(
    enter_state: On<EnterState>,
    mut q_repeater: Query<&mut Repeater>,
    q_substate_of: Query<&SubstateOf>,
    mut commands: Commands,
) where
    for<'a> <E as Event>::Trigger<'a>: Default,
{
    let state = enter_state.target;
    let Ok(mut repeater) = q_repeater.get_mut(state) else {
        return;
    };
    let root = q_substate_of.root_ancestor(state);

    if repeater.remaining > 0 {
        commands.trigger(E::repeat_tick(root));
        repeater.remaining -= 1;
    } else {
        commands.trigger(OnComplete::new(root));
    }
}

pub fn reset_repeater(reset: On<Reset>, mut q_repeater: Query<&mut Repeater>) {
    let state = reset.target;
    let Ok(mut repeater) = q_repeater.get_mut(state) else {
        return;
    };
    repeater.remaining = repeater.initial;
}

// ---------------------------------------------------------------------------
// template_repeater builder
// ---------------------------------------------------------------------------

pub fn template_repeater<E: Repeatable>(
    remaining: u32,
    delay_seconds: f32,
    on_repeat: impl FnOnce(&mut EntityCommands),
) -> impl FnOnce(&mut EntityCommands)
where
    for<'a> <E as Event>::Trigger<'a>: Default,
{
    move |parent_state: &mut EntityCommands| {
        let parent_entity = parent_state.id();
        parent_state.with_children(|parent| {
            let repeat = parent
                .spawn((
                    Name::new("Repeat"),
                    SubstateOf(parent_entity),
                    Repeater::new(remaining),
                ))
                .id();

            let apply = parent
                .spawn((
                    Name::new("RepeatApply"),
                    SubstateOf(parent_entity),
                    InvokedBy(parent_entity),
                ))
                .id();

            let mut apply_ec = parent.commands_mut().entity(apply);
            on_repeat(&mut apply_ec);

            parent.spawn((
                Name::new("OnRepeat"),
                Source(repeat),
                Target(apply),
                EventEdge::<E>::default(),
            ));

            parent.spawn((
                Name::new("RepeatDelay"),
                Source(apply),
                Target(repeat),
                AlwaysEdge,
                Delay {
                    duration: std::time::Duration::from_secs_f32(delay_seconds),
                },
            ));
        });
    }
}