brkrs 0.0.1

Breakout/Arkanoid-style game built in Rust using the Bevy engine, with physics powered by bevy_rapier3d
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

use bevy::prelude::*;

use brkrs::systems::textures::loader::{ObjectClass, TextureManifest, TypeVariantDefinition};
use brkrs::systems::textures::{
    FallbackRegistry, ProfileMaterialBank, TextureMaterialsPlugin, TypeVariantRegistry,
};

use brkrs::systems::textures::loader::RawTextureManifest as DiskTextureManifest;
use std::fs;

fn app_with_variant_registry() -> App {
    let mut app = App::new();
    app.add_plugins(MinimalPlugins);
    app.insert_resource(Assets::<StandardMaterial>::default());
    app.add_plugins(TextureMaterialsPlugin);
    app.update();
    app
}

#[test]
fn disk_manifest_populates_registry_for_new_bricks() {
    let mut app = app_with_variant_registry();

    // Prepare two distinct materials that will serve as profile outputs
    let (handle_a, handle_b) = {
        let mut materials = app.world_mut().resource_mut::<Assets<StandardMaterial>>();
        (
            materials.add(StandardMaterial {
                base_color: Color::srgba(0.5, 0.5, 0.5, 1.0),
                unlit: true,
                ..default()
            }),
            materials.add(StandardMaterial {
                base_color: Color::srgba(0.9, 0.2, 0.2, 1.0),
                unlit: true,
                ..default()
            }),
        )
    };

    // Populate profile material bank with the profile ids used by the on-disk manifest
    {
        let mut bank = app.world_mut().resource_mut::<ProfileMaterialBank>();
        bank.insert_for_tests("brick/type20", handle_a.clone());
        bank.insert_for_tests("brick/indestructible", handle_b.clone());
    }

    // Read manifest.ron from disk and build the runtime manifest
    let contents = fs::read_to_string("assets/textures/manifest.ron").expect("read manifest");
    // Deserialize into the disk manifest type used across the systems
    let raw_manifest: DiskTextureManifest =
        ron::de::from_str(&contents).expect("parse manifest ron");
    let manifest = brkrs::systems::textures::loader::TextureManifest::from_raw(raw_manifest);

    // Rebuild registry using the real manifest
    {
        let world = app.world_mut();
        world.resource_scope(|world, mut registry: Mut<TypeVariantRegistry>| {
            world.resource_scope(|world, bank: Mut<ProfileMaterialBank>| {
                world.resource_scope(|_world, mut fallback: Mut<FallbackRegistry>| {
                    registry.rebuild(&manifest, &bank, &mut fallback);
                });
            });
        });
    }

    // Ensure registry now contains mappings for the new brick types
    let reg = app.world().resource::<TypeVariantRegistry>();
    assert_eq!(
        reg.get(brkrs::systems::textures::loader::ObjectClass::Brick, 20)
            .unwrap(),
        handle_a
    );
    assert_eq!(
        reg.get(brkrs::systems::textures::loader::ObjectClass::Brick, 90)
            .unwrap(),
        handle_b
    );
}

#[test]
fn immediate_spawn_registry_populated_from_manifest() {
    let mut app = app_with_variant_registry();

    // Prepare materials handle(s)
    let handle_1 = {
        let mut materials = app.world_mut().resource_mut::<Assets<StandardMaterial>>();
        materials.add(StandardMaterial {
            base_color: Color::srgba(1.0, 0.0, 0.0, 1.0),
            unlit: true,
            ..default()
        })
    };

    // Populate profile material bank with a profile id used by the manifest variant
    {
        let mut bank = app.world_mut().resource_mut::<ProfileMaterialBank>();
        bank.insert_for_tests("ball/default", handle_1.clone());
    }

    // Create a runtime manifest with a variant mapping ball type 7 -> ball/default
    let manifest = TextureManifest {
        profiles: Default::default(),
        type_variants: vec![TypeVariantDefinition {
            object_class: ObjectClass::Ball,
            type_id: 7,
            profile_id: "ball/default".to_string(),
            emissive_color: None,
            animation: None,
        }],
        level_overrides: Default::default(),
        level_switch: None,
    };

    // Rebuild registry from manifest - need to scope borrows properly
    {
        let world = app.world_mut();
        world.resource_scope(|world, mut registry: Mut<TypeVariantRegistry>| {
            world.resource_scope(|world, bank: Mut<ProfileMaterialBank>| {
                world.resource_scope(|_world, mut fallback: Mut<FallbackRegistry>| {
                    registry.rebuild(&manifest, &bank, &mut fallback);
                });
            });
        });
    }

    // Now the registry should return the handle for (Ball, 7)
    let registry = app.world().resource::<TypeVariantRegistry>();
    let got = registry.get(ObjectClass::Ball, 7);
    assert!(got.is_some());
    assert_eq!(got.unwrap(), handle_1);
}

#[test]
fn runtime_mutation_updates_registry_mapping() {
    let mut app = app_with_variant_registry();

    // Create two distinct handles
    let (handle_a, handle_b) = {
        let mut materials = app.world_mut().resource_mut::<Assets<StandardMaterial>>();
        let a = materials.add(StandardMaterial {
            base_color: Color::srgba(0.1, 0.2, 0.3, 1.0),
            unlit: true,
            ..default()
        });
        let b = materials.add(StandardMaterial {
            base_color: Color::srgba(0.9, 0.8, 0.7, 1.0),
            unlit: true,
            ..default()
        });
        (a, b)
    };

    // Insert initial profile mapping to handle_a
    {
        let mut bank = app.world_mut().resource_mut::<ProfileMaterialBank>();
        bank.insert_for_tests("ball/default", handle_a.clone());
    }

    // Start manifest with mapping to handle_a
    let manifest = TextureManifest {
        profiles: Default::default(),
        type_variants: vec![TypeVariantDefinition {
            object_class: ObjectClass::Ball,
            type_id: 2,
            profile_id: "ball/default".to_string(),
            emissive_color: None,
            animation: None,
        }],
        level_overrides: Default::default(),
        level_switch: None,
    };

    // Rebuild registry from manifest
    {
        let world = app.world_mut();
        world.resource_scope(|world, mut registry: Mut<TypeVariantRegistry>| {
            world.resource_scope(|world, bank: Mut<ProfileMaterialBank>| {
                world.resource_scope(|_world, mut fallback: Mut<FallbackRegistry>| {
                    registry.rebuild(&manifest, &bank, &mut fallback);
                });
            });
        });
    }

    // Confirm initial mapping
    {
        let registry = app.world().resource::<TypeVariantRegistry>();
        assert_eq!(registry.get(ObjectClass::Ball, 2).unwrap(), handle_a);
    }

    // Mutate bank to point same profile id to a different handle, representing new baked material
    {
        let mut bank = app.world_mut().resource_mut::<ProfileMaterialBank>();
        bank.insert_for_tests("ball/default", handle_b.clone());
    }

    // Rebuild registry (as would happen on manifest/asset change)
    {
        let world = app.world_mut();
        world.resource_scope(|world, mut registry: Mut<TypeVariantRegistry>| {
            world.resource_scope(|world, bank: Mut<ProfileMaterialBank>| {
                world.resource_scope(|_world, mut fallback: Mut<FallbackRegistry>| {
                    registry.rebuild(&manifest, &bank, &mut fallback);
                });
            });
        });
    }

    // Confirm mapping updated to the new handle
    let registry = app.world().resource::<TypeVariantRegistry>();
    assert_eq!(registry.get(ObjectClass::Ball, 2).unwrap(), handle_b);
}