brdb 0.5.0

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

use brdb::{Brdb, IntoReader};
use std::path::PathBuf;

/// Reads a world and prints out all entities with their structs and class names
fn main() -> Result<(), Box<dyn std::error::Error>> {
    // world file from argv
    let filename = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "world.brdb".to_string());
    let path = PathBuf::from(filename);
    if !path.exists() {
        eprintln!("File does not exist: {}", path.display());
        std::process::exit(1);
    }

    let db = Brdb::open(path)?.into_reader();

    // Get global data to access entity type names and class names
    let data = db.global_data()?;
    println!("=== Entity Type Names ===");
    for ((i, name), class) in data
        .entity_type_names
        .iter()
        .enumerate()
        .zip(data.entity_data_class_names.iter())
    {
        println!("{i}: {name} - {class}");
    }
    println!();

    // Read all entity chunks
    println!("=== Entity Chunks ===");
    let entity_chunk_indices = db.entity_chunk_index()?;
    println!("Found {} entity chunks", entity_chunk_indices.len());
    println!();

    let mut total_entities = 0;
    for chunk_index in entity_chunk_indices {
        println!("--- Chunk {} ---", chunk_index);
        let entities = db.entity_chunk(chunk_index)?;

        for (i, entity) in entities.iter().enumerate() {
            total_entities += 1;
            println!("  Entity {i}:");
            println!("    Asset: {}", entity.asset);
            println!("    ID: {:?}", entity.id);
            println!("    Owner Index: {:?}", entity.owner_index);
            println!("    Location: {:?}", entity.location);
            println!("    Rotation: {:?}", entity.rotation);
            println!("    Velocity: {:?}", entity.velocity);
            println!("    Angular Velocity: {:?}", entity.angular_velocity);
            println!("    Frozen: {:?}", entity.frozen);
            println!("    Sleeping: {:?}", entity.sleeping);
            println!();
        }
    }

    println!("=== Summary ===");
    println!("Total entities: {total_entities}");

    // Also print the entity chunk SoA data
    println!();
    println!("=== Entity Chunk SoA Data ===");
    for chunk_index in db.entity_chunk_index()? {
        println!("--- Chunk {} (SoA) ---", chunk_index);
        let (soa, entity_data) = db.entity_chunk_soa(chunk_index)?;

        println!("  Type Counters: {:?}", soa.type_counters);
        println!("  Number of entities with data: {}", entity_data.len());

        for (i, data) in entity_data.iter().enumerate() {
            if let Some(struct_data) = data {
                println!("  Entity {i} struct: {struct_data}");
            } else {
                println!("  Entity {i}: None");
            }
        }
        println!();
    }

    Ok(())
}