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

use bevy::prelude::*;
use std::marker::PhantomData;

// ================= Periodic Effect Relationships =================

/// Entities affected by a periodic effect of type T.
#[derive(Component, Debug, PartialEq, Eq, Reflect)]
#[relationship_target(relationship = PeriodicEffectTarget<T>, linked_spawn)]
#[reflect(Component, FromWorld)]
pub struct PeriodicEffectTargets<T: Reflect> {
    #[entities]
    #[relationship]
    entities: Vec<Entity>,
    #[reflect(ignore)]
    _pd: PhantomData<T>,
}

impl<T: Reflect> Default for PeriodicEffectTargets<T> {
    fn default() -> Self {
        Self {
            entities: Vec::new(),
            _pd: PhantomData,
        }
    }
}

impl<T: Reflect> PeriodicEffectTargets<T> {
    pub fn iter(&self) -> impl Iterator<Item = Entity> + '_ {
        self.entities.iter().copied()
    }
}

/// Points an affected entity back to the periodic effect of type T.
#[derive(Component, Clone, Debug, Reflect)]
#[relationship(relationship_target = PeriodicEffectTargets<T>)]
#[reflect(Component, FromWorld, Default)]
pub struct PeriodicEffectTarget<T: Reflect> {
    #[entities]
    #[relationship]
    pub entity: Entity,
    #[reflect(ignore)]
    _pd: PhantomData<T>,
}

impl<T: Reflect> Default for PeriodicEffectTarget<T> {
    fn default() -> Self {
        Self {
            entity: Entity::PLACEHOLDER,
            _pd: PhantomData,
        }
    }
}

impl<T: Reflect> PeriodicEffectTarget<T> {
    pub fn new(entity: Entity) -> Self {
        Self {
            entity,
            _pd: PhantomData,
        }
    }
}

// ================= Periodic Tick Event =================

/// Fired each tick of a periodic effect. Observe to apply damage, healing, etc.
#[derive(EntityEvent, Clone, Debug, Reflect)]
pub struct PeriodicTick<T: Reflect> {
    #[event_target]
    pub target: Entity,
    pub source: Entity,
    #[reflect(ignore)]
    _pd: PhantomData<T>,
}

impl<T: Reflect> PeriodicTick<T> {
    pub fn new(source: Entity, target: Entity) -> Self {
        Self {
            target,
            source,
            _pd: PhantomData,
        }
    }
}

// ================= Tick System =================

/// Fires `PeriodicTick<T>` for all active effects. Run on a timer to control tick rate.
pub fn periodic_tick_system<T: Reflect + Component>(
    q_effects: Query<(Entity, &PeriodicEffectTargets<T>)>,
    mut commands: Commands,
) {
    for (source, targets) in q_effects.iter() {
        for target in targets.iter() {
            commands.trigger(PeriodicTick::<T>::new(source, target));
        }
    }
}