wow_dbc 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfaf18639315c2569395c416447ee1eb2d647497de512b0e717585b02678264d
-  data.tar.gz: 4d51845c28b8724a3d4ff3f672b499f727f5ad65bd3e3c9d116c4962d239691f
+  metadata.gz: daa39b72eec7d417d3777f459f768921622f1a0977eb4a2482c5115088b1bff7
+  data.tar.gz: e7ed2d3250a931ba99285ef60b7b793ef1ca322f5002b677f7a2de80ae8d4eab
 SHA512:
-  metadata.gz: 72da2052394e199fc40bd3a1aae3b54bbe1eb008c3431ce512dfd560230d2b42d7169e6ec68343efe5c7aad9d36a343205e18539a08e26b8b2df850e6c1e6146
-  data.tar.gz: a5bb33a31ca06b09775309fcd3f56ecc509f4ce08475bcd0df40a7d9aa9d0075e1194fbda498db3143cb7ae61a3ac5c7170608f84de2278ebb9f42b26abd725d
+  metadata.gz: 94eeb6ab0fcde158aada012a60fc0450cae3bd52763a964d044d3b2218fb59cbc23f6923be89e9d5252f1d33ec90459d72bae7960def2dff01ebb3842c2571ef
+  data.tar.gz: 83178273b7310b5f1fc0abbb435f07402ecbdfff288676b61f31a1c307d9b975e829a0060f8ff6daadecddf60767bc9cfd430168ae319bfbb6a6b25d38826b92

data/README.md

@@ -37,7 +37,16 @@ Here's a quick example of how to use WowDBC:
 require 'wow_dbc'
 
 # Correct field names for the Item.dbc file
-field_names = [:id, :class, :subclass, :sound_override_subclass, :material, :displayid, :inventory_type, :sheath_type]
+field_names = {
+  id: :uint32,
+  class: :uint32,
+  subclass: :uint32,
+  sound_override_subclass: :int32,
+  material: :uint32,
+  displayid: :uint32,
+  inventory_type: :uint32,
+  sheath_type: :uint32
+}
 
 # Open the Item.dbc file
 dbc = WowDBC::DBCFile.new('path/to/your/Item.dbc', field_names)

data/ext/wow_dbc/wow_dbc.c

@@ -3,6 +3,23 @@
 #include <stdint.h>
 #include <string.h>
 
+typedef enum {
+    TYPE_UINT32,
+    TYPE_INT32,
+    TYPE_FLOAT,
+    TYPE_STRING
+} FieldType;
+
+typedef struct {
+    FieldType type;
+    union {
+        uint32_t uint32_value;
+        int32_t int32_value;
+        float float_value;
+        uint32_t string_offset;
+    } value;
+} FieldValue;
+
 typedef struct {
     char magic[4];
     uint32_t record_count;
@@ -13,9 +30,9 @@ typedef struct {
 
 typedef struct {
     DBCHeader header;
-    uint32_t **records;
+    FieldValue **records;
     char *string_block;
-    VALUE field_names; // Ruby array of field names
+    VALUE field_definitions;  // Ruby hash of field names and types
 } DBCFile;
 
 static VALUE rb_mWowDBC;
@@ -38,8 +55,8 @@ static void dbc_free(void *ptr) {
 static size_t dbc_memsize(const void *ptr) {
     const DBCFile *dbc = (const DBCFile *)ptr;
     return sizeof(DBCFile) +
-           (dbc->header.record_count * sizeof(uint32_t *)) +
-           (dbc->header.record_count * dbc->header.field_count * sizeof(uint32_t)) +
+           (dbc->header.record_count * sizeof(FieldValue *)) +
+           (dbc->header.record_count * dbc->header.field_count * sizeof(FieldValue)) +
            dbc->header.string_block_size;
 }
 
@@ -56,13 +73,32 @@ static VALUE dbc_alloc(VALUE klass) {
     return TypedData_Wrap_Struct(klass, &dbc_data_type, dbc);
 }
 
-static VALUE dbc_initialize(VALUE self, VALUE filepath, VALUE field_names) {
+static FieldType ruby_to_field_type(VALUE type_value) {
+    ID type_id;
+
+    if (RB_TYPE_P(type_value, T_SYMBOL)) {
+        type_id = SYM2ID(type_value);
+    } else if (RB_TYPE_P(type_value, T_STRING)) {
+        type_id = rb_intern(StringValueCStr(type_value));
+    } else {
+        rb_raise(rb_eTypeError, "Field type must be a symbol or string, got %s", rb_obj_classname(type_value));
+    }
+
+    if (type_id == rb_intern("uint32")) return TYPE_UINT32;
+    if (type_id == rb_intern("int32")) return TYPE_INT32;
+    if (type_id == rb_intern("float")) return TYPE_FLOAT;
+    if (type_id == rb_intern("string")) return TYPE_STRING;
+
+    rb_raise(rb_eArgError, "Invalid field type: %s", rb_id2name(type_id));
+}
+
+static VALUE dbc_initialize(VALUE self, VALUE filepath, VALUE field_definitions) {
     DBCFile *dbc;
     TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
 
     rb_iv_set(self, "@filepath", filepath);
-    dbc->field_names = rb_ary_dup(field_names);
-    rb_iv_set(self, "@field_names", dbc->field_names);
+    dbc->field_definitions = rb_hash_dup(field_definitions);
+    rb_iv_set(self, "@field_definitions", dbc->field_definitions);
 
     return self;
 }
@@ -82,7 +118,6 @@ static VALUE dbc_read(VALUE self) {
         rb_raise(rb_eIOError, "Failed to read DBC header");
     }
 
-    // Free existing records if any
     if (dbc->records) {
         for (uint32_t i = 0; i < dbc->header.record_count; i++) {
             free(dbc->records[i]);
@@ -90,16 +125,42 @@ static VALUE dbc_read(VALUE self) {
         free(dbc->records);
     }
 
-    dbc->records = ALLOC_N(uint32_t *, dbc->header.record_count);
+    dbc->records = ALLOC_N(FieldValue *, dbc->header.record_count);
+    VALUE field_definitions = rb_iv_get(self, "@field_definitions");
+    VALUE field_names = rb_funcall(field_definitions, rb_intern("keys"), 0);
+
     for (uint32_t i = 0; i < dbc->header.record_count; i++) {
-        dbc->records[i] = ALLOC_N(uint32_t, dbc->header.field_count);
-        if (fread(dbc->records[i], sizeof(uint32_t), dbc->header.field_count, file) != dbc->header.field_count) {
-            fclose(file);
-            rb_raise(rb_eIOError, "Failed to read DBC record");
+        dbc->records[i] = ALLOC_N(FieldValue, dbc->header.field_count);
+        for (uint32_t j = 0; j < dbc->header.field_count; j++) {
+            VALUE field_name = rb_ary_entry(field_names, j);
+            VALUE field_type = rb_hash_aref(field_definitions, field_name);
+
+            FieldType type;
+            if (NIL_P(field_type)) {
+                type = TYPE_UINT32;  // Default to UINT32 if type is nil
+            } else {
+                type = ruby_to_field_type(field_type);
+            }
+            dbc->records[i][j].type = type;
+
+            if (fread(&dbc->records[i][j].value, sizeof(uint32_t), 1, file) != 1) {
+                fclose(file);
+                rb_raise(rb_eIOError, "Failed to read DBC record field");
+            }
+
+            switch (type) {
+                case TYPE_UINT32:
+                    break;
+                case TYPE_INT32:
+                    break;
+                case TYPE_FLOAT:
+                    break;
+                case TYPE_STRING:
+                    break;
+            }
         }
     }
 
-    // Free existing string block if any
     if (dbc->string_block) {
         free(dbc->string_block);
     }
@@ -111,6 +172,7 @@ static VALUE dbc_read(VALUE self) {
     }
 
     fclose(file);
+
     return self;
 }
 
@@ -130,9 +192,11 @@ static VALUE dbc_write(VALUE self) {
     }
 
     for (uint32_t i = 0; i < dbc->header.record_count; i++) {
-        if (fwrite(dbc->records[i], sizeof(uint32_t), dbc->header.field_count, file) != dbc->header.field_count) {
-            fclose(file);
-            rb_raise(rb_eIOError, "Failed to write DBC record");
+        for (uint32_t j = 0; j < dbc->header.field_count; j++) {
+            if (fwrite(&dbc->records[i][j].value, sizeof(uint32_t), 1, file) != 1) {
+                fclose(file);
+                rb_raise(rb_eIOError, "Failed to write DBC record field");
+            }
         }
     }
 
@@ -145,30 +209,62 @@ static VALUE dbc_write(VALUE self) {
     return self;
 }
 
+static VALUE field_value_to_ruby(FieldValue *value, char *string_block) {
+    switch (value->type) {
+        case TYPE_UINT32:
+            return UINT2NUM(value->value.uint32_value);
+        case TYPE_INT32:
+            return INT2NUM(value->value.int32_value);
+        case TYPE_FLOAT:
+            return DBL2NUM(value->value.float_value);
+        case TYPE_STRING:
+            return rb_str_new2(&string_block[value->value.string_offset]);
+    }
+    return Qnil;
+}
+
+static void ruby_to_field_value(VALUE ruby_value, FieldType type, FieldValue *field_value) {
+    field_value->type = type;
+    switch (type) {
+        case TYPE_UINT32:
+            field_value->value.uint32_value = NUM2UINT(ruby_value);
+            break;
+        case TYPE_INT32:
+            field_value->value.int32_value = NUM2INT(ruby_value);
+            break;
+        case TYPE_FLOAT:
+            field_value->value.float_value = (float)NUM2DBL(ruby_value);
+            break;
+        case TYPE_STRING:
+            field_value->value.string_offset = NUM2UINT(ruby_value);
+            break;
+    }
+}
+
 static VALUE dbc_create_record(VALUE self) {
     DBCFile *dbc;
     TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
 
     uint32_t new_count = dbc->header.record_count + 1;
-    REALLOC_N(dbc->records, uint32_t *, new_count);
-    dbc->records[new_count - 1] = ALLOC_N(uint32_t, dbc->header.field_count);
-    memset(dbc->records[new_count - 1], 0, dbc->header.field_count * sizeof(uint32_t));
+    REALLOC_N(dbc->records, FieldValue *, new_count);
+    dbc->records[new_count - 1] = ALLOC_N(FieldValue, dbc->header.field_count);
+    memset(dbc->records[new_count - 1], 0, dbc->header.field_count * sizeof(FieldValue));
 
     dbc->header.record_count = new_count;
 
     return INT2FIX(new_count - 1);
 }
 
-static VALUE dbc_update_record(VALUE self, VALUE index, VALUE field_name, VALUE value) {
+static VALUE dbc_update_record(VALUE self, VALUE index, VALUE field, VALUE value) {
     DBCFile *dbc;
     TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
 
     long idx = FIX2LONG(index);
     long field_idx = -1;
 
-    // Find the index of the field name
-    for (long i = 0; i < RARRAY_LEN(dbc->field_names); i++) {
-        if (rb_eql(rb_ary_entry(dbc->field_names, i), field_name)) {
+    VALUE field_names = rb_funcall(dbc->field_definitions, rb_intern("keys"), 0);
+    for (long i = 0; i < RARRAY_LEN(field_names); i++) {
+        if (rb_eql(rb_ary_entry(field_names, i), field)) {
             field_idx = i;
             break;
         }
@@ -178,25 +274,25 @@ static VALUE dbc_update_record(VALUE self, VALUE index, VALUE field_name, VALUE
         rb_raise(rb_eArgError, "Invalid record or field index");
     }
 
-    dbc->records[idx][field_idx] = NUM2UINT(value);
-
-    return Qnil;
-}
+    VALUE field_type = rb_hash_aref(dbc->field_definitions, field);
+    FieldType type = ruby_to_field_type(field_type);
 
-static VALUE dbc_delete_record(VALUE self, VALUE index) {
-    DBCFile *dbc;
-    TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
+    if (type == TYPE_STRING) {
+        // For string fields, we need to update the string block
+        char *str = StringValueCStr(value);
+        uint32_t offset = dbc->header.string_block_size;
+        uint32_t str_len = strlen(str) + 1;
 
-    long idx = FIX2LONG(index);
+        dbc->string_block = realloc(dbc->string_block, dbc->header.string_block_size + str_len);
+        memcpy(dbc->string_block + offset, str, str_len);
+        dbc->header.string_block_size += str_len;
 
-    if (idx < 0 || (uint32_t)idx >= dbc->header.record_count) {
-        rb_raise(rb_eArgError, "Invalid record index");
+        dbc->records[idx][field_idx].type = TYPE_STRING;
+        dbc->records[idx][field_idx].value.string_offset = offset;
+    } else {
+        ruby_to_field_value(value, type, &dbc->records[idx][field_idx]);
     }
 
-    free(dbc->records[idx]);
-    memmove(&dbc->records[idx], &dbc->records[idx + 1], (dbc->header.record_count - idx - 1) * sizeof(uint32_t *));
-    dbc->header.record_count--;
-
     return Qnil;
 }
 
@@ -211,9 +307,10 @@ static VALUE dbc_get_record(VALUE self, VALUE index) {
     }
 
     VALUE record = rb_hash_new();
+    VALUE field_names = rb_funcall(dbc->field_definitions, rb_intern("keys"), 0);
     for (uint32_t i = 0; i < dbc->header.field_count; i++) {
-        VALUE field_name = rb_ary_entry(dbc->field_names, i);
-        rb_hash_aset(record, field_name, UINT2NUM(dbc->records[idx][i]));
+        VALUE field_name = rb_ary_entry(field_names, i);
+        rb_hash_aset(record, field_name, field_value_to_ruby(&dbc->records[idx][i], dbc->string_block));
     }
 
     return record;
@@ -233,47 +330,47 @@ static VALUE dbc_get_header(VALUE self) {
     return header;
 }
 
-static VALUE dbc_create_record_with_values(VALUE self, VALUE initial_values) {
+static VALUE dbc_update_record_multi(VALUE self, VALUE index, VALUE updates) {
     DBCFile *dbc;
     TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
 
-    uint32_t new_count = dbc->header.record_count + 1;
-    REALLOC_N(dbc->records, uint32_t *, new_count);
-    dbc->records[new_count - 1] = ALLOC_N(uint32_t, dbc->header.field_count);
-    memset(dbc->records[new_count - 1], 0, dbc->header.field_count * sizeof(uint32_t));
+    long idx = FIX2LONG(index);
 
-    // Set initial values
-    if (RB_TYPE_P(initial_values, T_HASH)) {
-        VALUE keys = rb_funcall(initial_values, rb_intern("keys"), 0);
+    if (idx < 0 || (uint32_t)idx >= dbc->header.record_count) {
+        rb_raise(rb_eArgError, "Invalid record index");
+    }
+
+    if (RB_TYPE_P(updates, T_HASH)) {
+        VALUE keys = rb_funcall(updates, rb_intern("keys"), 0);
         for (long i = 0; i < RARRAY_LEN(keys); i++) {
             VALUE key = rb_ary_entry(keys, i);
-            VALUE value = rb_hash_aref(initial_values, key);
+            VALUE value = rb_hash_aref(updates, key);
             long field_idx = -1;
 
-            for (long j = 0; j < RARRAY_LEN(dbc->field_names); j++) {
-                if (rb_eql(rb_ary_entry(dbc->field_names, j), key)) {
+            VALUE field_names = rb_funcall(dbc->field_definitions, rb_intern("keys"), 0);
+            for (long j = 0; j < RARRAY_LEN(field_names); j++) {
+                if (rb_eql(rb_ary_entry(field_names, j), key)) {
                     field_idx = j;
                     break;
                 }
             }
 
             if (field_idx >= 0 && (uint32_t)field_idx < dbc->header.field_count) {
-                dbc->records[new_count - 1][field_idx] = NUM2UINT(value);
+                VALUE field_type = rb_hash_aref(dbc->field_definitions, key);
+                FieldType type = ruby_to_field_type(field_type);
+                ruby_to_field_value(value, type, &dbc->records[idx][field_idx]);
             } else {
-                // Free the allocated memory before raising the error
-                free(dbc->records[new_count - 1]);
-                REALLOC_N(dbc->records, uint32_t *, dbc->header.record_count);
-                rb_raise(rb_eArgError, "Invalid field name: %s", rb_id2name(SYM2ID(key)));
+                rb_raise(rb_eArgError, "Invalid field name: %"PRIsVALUE, key);
             }
         }
+    } else {
+        rb_raise(rb_eArgError, "Updates must be a hash");
     }
 
-    dbc->header.record_count = new_count;
-
-    return INT2FIX(new_count - 1);
+    return Qnil;
 }
 
-static VALUE dbc_update_record_multi(VALUE self, VALUE index, VALUE updates) {
+static VALUE dbc_delete_record(VALUE self, VALUE index) {
     DBCFile *dbc;
     TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
 
@@ -283,29 +380,9 @@ static VALUE dbc_update_record_multi(VALUE self, VALUE index, VALUE updates) {
         rb_raise(rb_eArgError, "Invalid record index");
     }
 
-    if (RB_TYPE_P(updates, T_HASH)) {
-        VALUE keys = rb_funcall(updates, rb_intern("keys"), 0);
-        for (long i = 0; i < RARRAY_LEN(keys); i++) {
-            VALUE key = rb_ary_entry(keys, i);
-            VALUE value = rb_hash_aref(updates, key);
-            long field_idx = -1;
-
-            for (long j = 0; j < RARRAY_LEN(dbc->field_names); j++) {
-                if (rb_eql(rb_ary_entry(dbc->field_names, j), key)) {
-                    field_idx = j;
-                    break;
-                }
-            }
-
-            if (field_idx >= 0 && (uint32_t)field_idx < dbc->header.field_count) {
-                dbc->records[idx][field_idx] = NUM2UINT(value);
-            } else {
-                rb_raise(rb_eArgError, "Invalid field name: %s", rb_id2name(SYM2ID(key)));
-            }
-        }
-    } else {
-        rb_raise(rb_eArgError, "Updates must be a hash");
-    }
+    free(dbc->records[idx]);
+    memmove(&dbc->records[idx], &dbc->records[idx + 1], (dbc->header.record_count - idx - 1) * sizeof(FieldValue *));
+    dbc->header.record_count--;
 
     return Qnil;
 }
@@ -315,10 +392,10 @@ static VALUE dbc_find_by(VALUE self, VALUE field, VALUE value) {
     TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
 
     long field_idx = -1;
+    VALUE field_names = rb_funcall(dbc->field_definitions, rb_intern("keys"), 0);
 
-    // Find the index of the field name
-    for (long i = 0; i < RARRAY_LEN(dbc->field_names); i++) {
-        if (rb_eql(rb_ary_entry(dbc->field_names, i), field)) {
+    for (long i = 0; i < RARRAY_LEN(field_names); i++) {
+        if (rb_eql(rb_ary_entry(field_names, i), field)) {
             field_idx = i;
             break;
         }
@@ -331,11 +408,12 @@ static VALUE dbc_find_by(VALUE self, VALUE field, VALUE value) {
     VALUE result = rb_ary_new();
 
     for (uint32_t i = 0; i < dbc->header.record_count; i++) {
-        if (dbc->records[i][field_idx] == NUM2UINT(value)) {
+        VALUE field_value = field_value_to_ruby(&dbc->records[i][field_idx], dbc->string_block);
+        if (rb_eql(field_value, value)) {
             VALUE record = rb_hash_new();
             for (uint32_t j = 0; j < dbc->header.field_count; j++) {
-                VALUE field_name = rb_ary_entry(dbc->field_names, j);
-                rb_hash_aset(record, field_name, UINT2NUM(dbc->records[i][j]));
+                VALUE field_name = rb_ary_entry(field_names, j);
+                rb_hash_aset(record, field_name, field_value_to_ruby(&dbc->records[i][j], dbc->string_block));
             }
             rb_ary_push(result, record);
         }
@@ -362,9 +440,11 @@ static VALUE dbc_write_to(VALUE self, VALUE new_filepath) {
     }
 
     for (uint32_t i = 0; i < dbc->header.record_count; i++) {
-        if (fwrite(dbc->records[i], sizeof(uint32_t), dbc->header.field_count, file) != dbc->header.field_count) {
-            fclose(file);
-            rb_raise(rb_eIOError, "Failed to write DBC record");
+        for (uint32_t j = 0; j < dbc->header.field_count; j++) {
+            if (fwrite(&dbc->records[i][j].value, sizeof(uint32_t), 1, file) != 1) {
+                fclose(file);
+                rb_raise(rb_eIOError, "Failed to write DBC record");
+            }
         }
     }
 
@@ -377,6 +457,72 @@ static VALUE dbc_write_to(VALUE self, VALUE new_filepath) {
     return self;
 }
 
+static VALUE dbc_create_record_with_values(VALUE self, VALUE values) {
+    DBCFile *dbc;
+    TypedData_Get_Struct(self, DBCFile, &dbc_data_type, dbc);
+
+    if (!RB_TYPE_P(values, T_HASH)) {
+        rb_raise(rb_eArgError, "Values must be a hash");
+    }
+
+    // Check for invalid field names
+    VALUE keys = rb_funcall(values, rb_intern("keys"), 0);
+    for (long i = 0; i < RARRAY_LEN(keys); i++) {
+        VALUE key = rb_ary_entry(keys, i);
+        if (NIL_P(rb_hash_aref(dbc->field_definitions, key))) {
+            rb_raise(rb_eArgError, "Invalid field name: %"PRIsVALUE, key);
+        }
+    }
+
+    uint32_t new_count = dbc->header.record_count + 1;
+    REALLOC_N(dbc->records, FieldValue *, new_count);
+    dbc->records[new_count - 1] = ALLOC_N(FieldValue, dbc->header.field_count);
+
+    VALUE field_names = rb_funcall(dbc->field_definitions, rb_intern("keys"), 0);
+    for (uint32_t i = 0; i < dbc->header.field_count; i++) {
+        VALUE field_name = rb_ary_entry(field_names, i);
+        VALUE value = rb_hash_aref(values, field_name);
+        VALUE field_type = rb_hash_aref(dbc->field_definitions, field_name);
+        FieldType type = ruby_to_field_type(field_type);
+
+        if (NIL_P(value)) {
+            // Set default values for missing fields
+            switch (type) {
+                case TYPE_UINT32:
+                case TYPE_INT32:
+                    dbc->records[new_count - 1][i].value.uint32_value = 0;
+                    break;
+                case TYPE_FLOAT:
+                    dbc->records[new_count - 1][i].value.float_value = 0.0f;
+                    break;
+                case TYPE_STRING:
+                    dbc->records[new_count - 1][i].value.string_offset = 0; // Empty string
+                    break;
+            }
+        } else {
+            if (type == TYPE_STRING) {
+                char *str = StringValueCStr(value);
+                uint32_t offset = dbc->header.string_block_size;
+                uint32_t str_len = strlen(str) + 1;
+
+                dbc->string_block = realloc(dbc->string_block, dbc->header.string_block_size + str_len);
+                memcpy(dbc->string_block + offset, str, str_len);
+                dbc->header.string_block_size += str_len;
+
+                dbc->records[new_count - 1][i].type = TYPE_STRING;
+                dbc->records[new_count - 1][i].value.string_offset = offset;
+            } else {
+                ruby_to_field_value(value, type, &dbc->records[new_count - 1][i]);
+            }
+        }
+        dbc->records[new_count - 1][i].type = type;
+    }
+
+    dbc->header.record_count = new_count;
+
+    return INT2FIX(new_count - 1);
+}
+
 void Init_wow_dbc(void) {
     rb_mWowDBC = rb_define_module("WowDBC");
     rb_cDBCFile = rb_define_class_under(rb_mWowDBC, "DBCFile", rb_cObject);

data/lib/wow_dbc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WowDBC
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wow_dbc
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - sebi