bevy_bundlication 0.0.1

Network replication for bevy based on a bundle pattern
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 super::{
    Authority, Buffers, Direction, Identifier, IdentifierMap, Identity, Owner, RegisteredBundle,
    RegistryDir, Tick,
};

use bevy::{
    ecs::archetype::{ArchetypeGeneration, ArchetypeId, Archetypes},
    prelude::*,
};

pub fn iterate_world<Dir: Direction>(world: &mut World) {
    let mut new_clients = Vec::with_capacity(20);

    if let Some(mut events) = world.get_resource_mut::<Events<super::NewConnection>>() {
        new_clients.extend(events.drain().filter_map(|e| {
            let Identity::Client(client_id) = *e else {
                return None;
            };
            Some(client_id)
        }));
    }

    let Some(mut buffers) = world.remove_resource::<Buffers>() else {
        return;
    };
    let tick = world.remove_resource::<Tick>().unwrap();
    let id_map = world.remove_resource::<IdentifierMap>().unwrap();
    let ident = world.remove_resource::<Identity>().unwrap();

    let mut cache = world
        .remove_resource::<ArchetypeCache>()
        .unwrap_or_default();

    let archetypes = world.archetypes();

    update_archetype_cache::<Dir>(world, archetypes, cache.generation, &mut cache);
    cache.generation = archetypes.generation();

    for entry in cache.list.iter() {
        let archetype = archetypes.get(entry.archetype).unwrap();

        for entity in archetype.entities().iter() {
            let entity = world.entity(entity.entity());
            let id = entity.get::<Identifier>().unwrap();
            let owner = match entry.has_owner {
                true => entity.get::<Owner>(),
                false => None,
            };
            let authority = match entry.has_authority {
                true => entity.get::<Authority>(),
                false => None,
            };

            for bundle in entry.bundles.iter() {
                (bundle.serialize)(
                    *id,
                    owner,
                    authority,
                    &entity,
                    bundle.packet_id,
                    &mut buffers,
                    &id_map,
                    tick,
                    ident,
                    &new_clients,
                );
            }
        }
    }

    world.insert_resource(cache);
    world.insert_resource(ident);
    world.insert_resource(id_map);
    world.insert_resource(tick);
    world.insert_resource(buffers);
}

#[derive(Resource)]
pub struct ArchetypeCache {
    list: Vec<ArchetypeCacheEntry>,
    generation: ArchetypeGeneration,
}

impl Default for ArchetypeCache {
    fn default() -> Self {
        Self {
            list: default(),
            generation: ArchetypeGeneration::initial(),
        }
    }
}

pub struct ArchetypeCacheEntry {
    archetype: ArchetypeId,
    has_owner: bool,
    has_authority: bool,
    bundles: Vec<RegisteredBundle>,
}

fn update_archetype_cache<Dir: Direction>(
    world: &World,
    archetypes: &Archetypes,
    since: ArchetypeGeneration,
    cache: &mut ArchetypeCache,
) {
    let Some(marker_id) = world.component_id::<Identifier>() else {
        return;
    };
    let owner_id = world.component_id::<Owner>();
    let authority_id = world.component_id::<Authority>();
    let reg = world.resource::<RegistryDir<Dir>>();

    for archetype in &archetypes[since..] {
        if !archetype.contains(marker_id) {
            continue;
        }

        let mut bundles = Vec::with_capacity(5);
        'bundle_loop: for (_, bundle) in reg.bundles.iter() {
            for comp in bundle.component_ids.iter() {
                if !archetype.contains(*comp) {
                    continue 'bundle_loop;
                }
            }
            bundles.push(bundle.clone());
        }

        if bundles.is_empty() {
            continue;
        }

        cache.list.push(ArchetypeCacheEntry {
            archetype: archetype.id(),
            has_owner: owner_id.is_some() && archetype.contains(owner_id.unwrap()),
            has_authority: authority_id.is_some() && archetype.contains(authority_id.unwrap()),
            bundles,
        });
    }
}