wasvy 0.0.8

Bevy WASM
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

use bevy_ecs::{
    entity::EntityHashSet,
    prelude::*,
    schedule::{ScheduleCleanupPolicy, ScheduleError},
    system::SystemState,
};
use bevy_log::prelude::*;
use bevy_platform::collections::{HashMap, HashSet};

use crate::{
    mods::{ModDespawnBehaviour, ModSystemSet},
    prelude::ModSchedules,
};

/// A [Message] that triggers disabling of scheduled [ModSystemSets](ModSystemSet).
///
/// For ease of use within component hooks, this is also a command that can be enqueued like any other.
///
/// This is a message because it must run during the setup_schedule. This way
/// it can cleanup all schedules, including the one from which the message was written.
#[derive(Message)]
pub(crate) struct DisableSystemSet {
    pub(crate) set: ModSystemSet,
    pub(crate) schedules: ModSchedules,
}

impl Command<()> for DisableSystemSet {
    fn apply(self, world: &mut World) {
        if !self.schedules.0.is_empty() {
            world.write_message(self);
        }
    }
}

pub(crate) fn disable_mod_system_sets(
    world: &mut World,
    param: &mut SystemState<MessageReader<DisableSystemSet>>,
) {
    let mut messages = param.get_mut(world);

    // Collect a map of unique bevy schedule labels and the sets that need to be removed from them
    let mut remove = HashMap::new();
    for DisableSystemSet { set, schedules } in messages.read() {
        for schedule in schedules.0.iter() {
            remove
                .entry(schedule.schedule_label())
                .or_insert(HashSet::new())
                .insert(set.clone());
        }
    }

    // Remove sets from each schedule
    for (label, sets) in remove {
        let mut schedules = world
            .get_resource_mut::<Schedules>()
            .expect("Running in a bevy App");

        // We must remove and then re-add the schedule so we can call remove_systems_in_set with exclusive world access
        let Some(mut schedule) = schedules.remove(label) else {
            continue;
        };

        for set in sets {
            if let Err(error) = schedule.remove_systems_in_set(
                set.clone(),
                world,
                ScheduleCleanupPolicy::RemoveSetAndSystems,
            ) && !matches!(error, ScheduleError::SetNotFound)
            {
                warn!(
                    "Unable to remove system set {set:?}. Systems from unloaded mods might still be running!\nError: {error}."
                );
            }
        }

        world
            .get_resource_mut::<Schedules>()
            .expect("Running in a bevy App")
            .insert(schedule);
    }
}

/// A component that tracks all of the entities spawned by a mod (and considered belonging to it).
///
/// When a mod is despawned, so will all the entities it spawned due to the `linked_spawn` clause of the relationship.
#[derive(Component, Default)]
#[relationship_target(relationship = DespawnModEntity, linked_spawn)]
pub(crate) struct DespawnModEntities(EntityHashSet);

/// A component that tracks the mod responsible for spawning an entity.
#[derive(Component)]
#[relationship(relationship_target = DespawnModEntities)]
pub(crate) struct DespawnModEntity(pub(crate) Entity);

/// Determines whether [DespawnModEntity] should be inserted to entities spawned by mods
#[derive(Clone, Copy)]
pub(crate) struct InsertDespawnComponent(pub(crate) Option<Entity>);

impl InsertDespawnComponent {
    pub(crate) fn new(mod_id: Entity, world: &World) -> Self {
        Self(if ModDespawnBehaviour::should_despawn_entities(world) {
            Some(mod_id)
        } else {
            None
        })
    }
}