wow-cdbc 0.6.2

Parser for World of Warcraft DBC (client database) files with serialization support
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

use clap::{Parser, Subcommand};
use std::fs::File;
use std::io::BufReader;
use std::path::PathBuf;
use wow_cdbc::{DbcParser, FieldType, Schema, SchemaField, export_to_csv, export_to_json};

#[derive(Parser)]
#[command(name = "dbc_tool")]
#[command(about = "A tool for working with World of Warcraft DBC files", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Display information about a DBC file
    Info {
        /// The DBC file to analyze
        file: PathBuf,
    },
    /// Export DBC data to JSON
    ExportJson {
        /// The DBC file to export
        file: PathBuf,
        /// Output JSON file
        output: PathBuf,
        /// Schema file (YAML)
        #[arg(short, long)]
        schema: Option<PathBuf>,
    },
    /// Export DBC data to CSV
    ExportCsv {
        /// The DBC file to export
        file: PathBuf,
        /// Output CSV file
        output: PathBuf,
        /// Schema file (YAML)
        #[arg(short, long)]
        schema: Option<PathBuf>,
    },
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let cli = Cli::parse();

    match cli.command {
        Commands::Info { file } => {
            let mut reader = BufReader::new(File::open(&file)?);
            let parser = DbcParser::parse(&mut reader)?;
            let header = parser.header();

            println!("DBC File Information:");
            println!("  Magic: {}", String::from_utf8_lossy(&header.magic));
            println!("  Records: {}", header.record_count);
            println!("  Fields: {}", header.field_count);
            println!("  Record Size: {} bytes", header.record_size);
            println!("  String Block Size: {} bytes", header.string_block_size);
        }
        Commands::ExportJson {
            file,
            output,
            schema: _schema,
        } => {
            // For now, use a simple schema
            let data = std::fs::read(&file)?;
            let parser = DbcParser::parse_bytes(&data)?;

            // Create a basic schema (in real use, this would be loaded from the schema file)
            let mut schema = Schema::new("DBC");
            // Add fields based on field count
            let field_count = parser.header().field_count;
            for i in 0..field_count {
                schema.add_field(SchemaField::new(format!("Field{i}"), FieldType::UInt32));
            }

            let parser = parser.with_schema(schema)?;
            let record_set = parser.parse_records()?;

            let json_output = File::create(output)?;
            export_to_json(&record_set, json_output)?;

            println!("Exported to JSON successfully");
        }
        Commands::ExportCsv {
            file,
            output,
            schema: _schema,
        } => {
            // For now, use a simple schema
            let data = std::fs::read(&file)?;
            let parser = DbcParser::parse_bytes(&data)?;

            // Create a basic schema
            let mut schema = Schema::new("DBC");
            let field_count = parser.header().field_count;
            for i in 0..field_count {
                schema.add_field(SchemaField::new(format!("Field{i}"), FieldType::UInt32));
            }

            let parser = parser.with_schema(schema)?;
            let record_set = parser.parse_records()?;

            let csv_output = File::create(output)?;
            export_to_csv(&record_set, csv_output)?;

            println!("Exported to CSV successfully");
        }
    }

    Ok(())
}