brdb 0.6.4

A library for reading and writing Brickadia's World files.
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

//! Scratch dump tool for inspecting the new brs-js fixtures (wires,
//! components, entities). Mirrors examples/read_brz.rs (global data, brick
//! chunk SoA, component chunk SoA + per-instance component list, wire chunk
//! SoA), generalized to accept any grid id and either a .brz or .brdb path,
//! plus (for entities) the entity chunk index/SoA dump from
//! examples/read_entities.rs. Not part of the committed example set — purely
//! a debugging aid for writing the report's ground-truth dumps.
use brdb::{BrFsReader, Brdb, BrReader, Brz, IntoReader, WireChunkSoA};
use std::path::PathBuf;

fn run<T: BrFsReader>(db: &BrReader<T>) -> Result<(), Box<dyn std::error::Error>> {
    let data = db.global_data()?;
    println!("Basic Brick assets: {:?}", data.basic_brick_asset_names);
    println!("Procedural Brick assets: {:?}", data.procedural_brick_asset_names);
    // register_all_components() embeds the FULL catalog (hundreds of wire
    // ports/component types), so only print counts for those — the fixture's
    // OWN types/ports are visible per-brick below via the type-name lookups.
    println!(
        "Wire port count: {} (registered catalog)",
        data.component_wire_port_names.len()
    );
    println!(
        "Component type count: {} (registered catalog)",
        data.component_type_names.len()
    );
    println!("Entity types: {:?}", data.entity_type_names);
    println!("Entity classes: {:?}", data.entity_data_class_names);

    // Probe grid ids 1.. until one is missing (grid 1 is always the main
    // grid; higher ids are sub-grids / microchip inner grids).
    for gid in 1..32 {
        let chunks = match db.brick_chunk_index(gid) {
            Ok(c) => c,
            Err(_) => break,
        };
        println!("=== grid {gid} ===");
        println!("Brick chunks: {chunks:?}");
        for chunk in &chunks {
            let soa = db.brick_chunk_soa(gid, chunk.index)?;
            println!("Brick soa: {soa:?}");
            let asset_names: Vec<String> = soa
                .brick_type_indices
                .iter()
                .map(|&t| {
                    if (t as usize) < soa.procedural_brick_starting_index as usize {
                        data.basic_brick_asset_names
                            .get_index(t as usize)
                            .cloned()
                            .unwrap_or_default()
                    } else {
                        "<procedural>".to_string()
                    }
                })
                .collect();
            println!("Brick asset names (by index in chunk): {asset_names:?}");

            if chunk.num_components > 0 {
                let (soa, components) = db.component_chunk_soa(gid, chunk.index)?;
                let type_names: Vec<String> = soa
                    .component_type_counters
                    .iter()
                    .flat_map(|c| {
                        let name = data
                            .component_type_names
                            .get_index(c.type_index as usize)
                            .cloned()
                            .unwrap_or_default();
                        (0..c.num_instances).map(move |_| name.clone())
                    })
                    .collect();
                println!(
                    "Component chunk soa: component_brick_indices={:?} microchip_brick_indices={:?} microchip_brick_grid_references={:?}",
                    soa.component_brick_indices,
                    soa.microchip_brick_indices,
                    soa.microchip_brick_grid_references
                );
                println!("Component type names (parallel to ComponentBrickIndices): {type_names:?}");
                for c in components {
                    println!("Component: {c}");
                }
            }
            if chunk.num_wires > 0 {
                let raw = db.wire_chunk_soa(gid, chunk.index)?;
                println!("Wire chunk soa (raw struct): {raw}");
                let value = raw.to_value();
                let soa: WireChunkSoA = (&value).try_into()?;
                let port_name = |i: u16| {
                    data.component_wire_port_names
                        .get_index(i as usize)
                        .cloned()
                        .unwrap_or_default()
                };
                let type_name = |i: u16| {
                    data.component_type_names
                        .get_index(i as usize)
                        .cloned()
                        .unwrap_or_default()
                };
                for s in &soa.local_wire_sources {
                    println!(
                        "  local source: brick_in_chunk={} type={} port={}",
                        s.brick_index_in_chunk,
                        type_name(s.component_type_index),
                        port_name(s.port_index)
                    );
                }
                for t in &soa.local_wire_targets {
                    println!(
                        "  local target: brick_in_chunk={} type={} port={}",
                        t.brick_index_in_chunk,
                        type_name(t.component_type_index),
                        port_name(t.port_index)
                    );
                }
                for s in &soa.remote_wire_sources {
                    println!(
                        "  remote source: grid_persistent_index={} chunk={} brick_in_chunk={} type={} port={}",
                        s.grid_persistent_index,
                        s.chunk_index,
                        s.brick_index_in_chunk,
                        type_name(s.component_type_index),
                        port_name(s.port_index)
                    );
                }
                for t in &soa.remote_wire_targets {
                    println!(
                        "  remote target: brick_in_chunk={} type={} port={}",
                        t.brick_index_in_chunk,
                        type_name(t.component_type_index),
                        port_name(t.port_index)
                    );
                }
            }
        }
    }

    // Entity chunks (present whenever the world has any grids/entities).
    let entity_chunk_indices = db.entity_chunk_index()?;
    println!("=== entities ===");
    println!("Entity chunk indices: {entity_chunk_indices:?}");
    for chunk_index in entity_chunk_indices {
        let (soa, entity_data) = db.entity_chunk_soa(chunk_index)?;
        println!("--- Chunk {chunk_index} (SoA) ---");
        println!("Type counters: {:?}", soa.type_counters);
        let type_names: Vec<String> = soa
            .type_counters
            .iter()
            .flat_map(|c| {
                let name = data
                    .entity_type_names
                    .get_index(c.type_index as usize)
                    .cloned()
                    .unwrap_or_default();
                (0..c.num_entities).map(move |_| name.clone())
            })
            .collect();
        println!("Entity type names (parallel to PersistentIndices): {type_names:?}");
        println!("Persistent indices: {:?}", soa.persistent_indices);
        println!("Locations: {:?}", soa.locations);
        println!("Rotations: {:?}", soa.rotations);
        println!("Physics locked (frozen): {:?}", soa.physics_locked_flags);
        println!("Physics sleeping: {:?}", soa.physics_sleeping_flags);
        for (i, data) in entity_data.iter().enumerate() {
            match data {
                Some(struct_data) => println!("  Entity {i} struct: {struct_data}"),
                None => println!("  Entity {i}: None"),
            }
        }
    }

    println!("Files: {}", db.get_fs()?.render());

    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let p = PathBuf::from(std::env::args().nth(1).unwrap());
    if p.extension().and_then(|e| e.to_str()) == Some("brdb") {
        run(&Brdb::open(&p)?.into_reader())
    } else {
        run(&Brz::open(&p)?.into_reader())
    }
}