bevy_gauge 0.1.2

bevy_gauge - a flexible stats system 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

use bevy::ecs::relationship::Relationship;
use bevy::prelude::*;
use crate::prelude::*;
use crate::schedule::StatsMutation;
use bevy::platform::collections::HashMap as BevyHashMap;
use std::any::TypeId;

#[derive(Resource, Default)]
pub(crate) struct StatRelationshipAliases(BevyHashMap<TypeId, &'static str>);

fn derive_alias<R: 'static>() -> &'static str {
    let full = std::any::type_name::<R>();
    let last = full.rsplit("::").next().unwrap_or(full);
    match last.find('<') { Some(pos) => &last[..pos], None => last }
}

fn get_alias_for<R: 'static>(aliases: &StatRelationshipAliases) -> &'static str {
    aliases.0.get(&TypeId::of::<R>()).copied().unwrap_or_else(|| derive_alias::<R>())
}

pub(crate) fn on_edge_changed_system<R>(
    q: Query<(Entity, &R), (With<Stats>, Changed<R>)>,
    mut stats_mutator: StatsMutator,
    aliases: Res<StatRelationshipAliases>,
) where
    R: Relationship + Component + Send + Sync + 'static,
{
    let alias = get_alias_for::<R>(&aliases);
    for (entity, edge) in &q {
        if let Ok(stats_ro) = stats_mutator.get_stats(entity) {
            if let Some(&old_source) = stats_ro.sources.get(alias) {
                let src = edge.get();
                if old_source != src {
                    stats_mutator.unregister_source(entity, alias);
                }
            }
        }
        stats_mutator.register_source(entity, alias, edge.get());
    }
}

pub(crate) fn on_edge_removed_system<R>(
    mut removed: RemovedComponents<R>,
    mut stats_mutator: StatsMutator,
    aliases: Res<StatRelationshipAliases>,
) where
    R: Component + Send + Sync + 'static,
{
    let alias = get_alias_for::<R>(&aliases);
    for entity in removed.read() { stats_mutator.unregister_source(entity, alias); }
}

pub trait StatsAppSourcesExt {
    fn register_stat_relationship<R>(&mut self) -> &mut Self
    where R: Relationship + Component + Send + Sync + 'static;

    fn register_stat_relationship_as<R>(&mut self, alias: &'static str) -> &mut Self
    where R: Relationship + Component + Send + Sync + 'static;

    fn register_stat_relationship_with<R>(&mut self, extractor: fn(&R) -> Entity) -> &mut Self
    where R: Component + Send + Sync + 'static;

    fn register_stat_relationship_as_with<R>(&mut self, alias: &'static str, extractor: fn(&R) -> Entity) -> &mut Self
    where R: Component + Send + Sync + 'static;
}

impl StatsAppSourcesExt for App {
    fn register_stat_relationship<R>(&mut self) -> &mut Self
    where R: Relationship + Component + Send + Sync + 'static {
        let alias = derive_alias::<R>();
        StatsAppSourcesExt::register_stat_relationship_as::<R>(self, alias)
    }

    fn register_stat_relationship_as<R>(&mut self, alias: &'static str) -> &mut Self
    where R: Relationship + Component + Send + Sync + 'static {
        self.init_resource::<StatRelationshipAliases>();
        {
            let world = self.world_mut();
            let mut aliases_map = world.resource_mut::<StatRelationshipAliases>();
            aliases_map.0.insert(TypeId::of::<R>(), alias);
        }
        self.add_systems(StatsMutation, on_edge_changed_system::<R>);
        self.add_systems(StatsMutation, on_edge_removed_system::<R>);
        self
    }

    fn register_stat_relationship_with<R>(&mut self, extractor: fn(&R) -> Entity) -> &mut Self
    where R: Component + Send + Sync + 'static {
        let alias = derive_alias::<R>();
        StatsAppSourcesExt::register_stat_relationship_as_with::<R>(self, alias, extractor)
    }

    fn register_stat_relationship_as_with<R>(&mut self, alias: &'static str, extractor: fn(&R) -> Entity) -> &mut Self
    where R: Component + Send + Sync + 'static {
        self.init_resource::<StatRelationshipAliases>();
        {
            let world = self.world_mut();
            let mut aliases_map = world.resource_mut::<StatRelationshipAliases>();
            aliases_map.0.insert(TypeId::of::<R>(), alias);
        }
        self.add_systems(StatsMutation, move |q: Query<(Entity, &R), (With<Stats>, Changed<R>)>, mut stats_mutator: StatsMutator, aliases: Res<StatRelationshipAliases>| {
            let alias = get_alias_for::<R>(&aliases);
            for (entity, edge) in &q {
                let src = extractor(edge);
                if let Ok(stats_ro) = stats_mutator.get_stats(entity) {
                    if let Some(&old_source) = stats_ro.sources.get(alias) {
                        if old_source != src { stats_mutator.unregister_source(entity, alias); }
                    }
                }
                stats_mutator.register_source(entity, alias, src);
            }
        });

        self.add_systems(StatsMutation, move |mut removed: RemovedComponents<R>, mut stats_mutator: StatsMutator, aliases: Res<StatRelationshipAliases>| {
            let alias = get_alias_for::<R>(&aliases);
            for entity in removed.read() { stats_mutator.unregister_source(entity, alias); }
        });

        self
    }
}