block.h

#ifndef LEVELZ_BLOCK_H
#define LEVELZ_BLOCK_H
 
#define _BLOCK_PROPERTIES_INIT_CAPACITY 16
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "coordinate.h"
 
typedef struct BlockProperty {
    char* name;
    
    char* value;
} BlockProperty;
 
typedef struct Block {
    char* name;
    
    BlockProperty** properties;
 
    int propertyCount;
 
    int propertyCapacity;
} Block;
 
Block* createBlock(char* name) {
    Block* b = (Block*) malloc(sizeof(Block));
    b->name = name;
    b->propertyCount = 0;
    b->propertyCapacity = _BLOCK_PROPERTIES_INIT_CAPACITY;
    b->properties = (BlockProperty**) malloc(b->propertyCapacity * sizeof(BlockProperty*));
    
    return b;
}
 
char* Block_getProperty(Block* b, char* name) {
    if (b == 0) return 0;
    if (name == 0) return 0;
 
    for (int i = 0; i < b->propertyCount; i++) {
        if (strcmp(b->properties[i]->name, name) == 0) {
            return b->properties[i]->value;
        }
    }
 
    return "";
}
 
void Block_setProperty(Block* b, char* name, char* value) {
    if (b == 0) return;
    if (name == 0) return;
    if (value == 0) return;
 
    for (int i = 0; i < b->propertyCount; i++) {
        if (strcmp(b->properties[i]->name, name) == 0) {
            b->properties[i]->value = value;
            return;
        }
    }
 
    BlockProperty* p = (BlockProperty*) malloc(sizeof(BlockProperty));
    p->name = strcpy((char*) malloc(strlen(name) + 1), name);
    p->value = strcpy((char*) malloc(strlen(value) + 1), value);
 
    if (b->propertyCount == b->propertyCapacity) {
        b->propertyCapacity *= 2;
        b->properties = (BlockProperty**) realloc(b->properties, b->propertyCapacity * sizeof(BlockProperty*));
    }
 
    b->properties[b->propertyCount] = p;
    b->propertyCount++;
 
    return;
}
 
void Block_removeProperty(Block* b, char* name) {
    if (b == 0) return;
    if (name == 0) return;
    if (b->propertyCount == 0) return;
 
    for (int i = 0; i < b->propertyCount; i++) {
        if (strcmp(b->properties[i]->name, name) == 0) {
            free(b->properties[i]);
            for (int j = i; j < b->propertyCount - 1; j++) {
                b->properties[j] = b->properties[j + 1];
            }
            b->propertyCount--;
            return;
        }
    
        if (b->propertyCount < b->propertyCapacity / 2) {
            b->propertyCapacity /= 2;
            b->properties = (BlockProperty**) realloc(b->properties, b->propertyCapacity * sizeof(BlockProperty*));
        }
    }
}
 
char* Block_toString(Block* b) {
    if (b == 0) return 0;
 
    char* name = (char*) malloc(strlen(b->name) + 1);
    sprintf(name, "%s", b->name);
 
    if (b->propertyCount == 0)
        return name;
    
    int bytes = strlen(name) + 1;
    for (int i = 0; i < b->propertyCount; i++) {
        bytes += strlen(b->properties[i]->name) + strlen(b->properties[i]->value) + 4;
    }
 
    char* str = (char*) malloc(bytes);
    sprintf(str, "%s<", name);
 
    for (int i = 0; i < b->propertyCount; i++) {
        sprintf(str, "%s%s=%s", str, b->properties[i]->name, b->properties[i]->value);
        if (i < b->propertyCount - 1)
            sprintf(str, "%s, ", str);
    }
 
    int l = strlen(str);
    if (str[l - 1] != '>')
        sprintf(str, "%s>", str);
 
    return str;
}
 
Block* Block_fromString(const char* str) {
    if (str == 0) return 0;
 
    int l = strlen(str);
    if (l == 0) return 0;
 
    char* str0 = (char*) malloc(l + 1);
    strcpy(str0, str);
 
    char* name = strtok(str0, "<");
    if (name == 0) {
        free(str0);
        return 0;
    }
 
    char* name0 = (char*) malloc(strlen(name) + 1);
    strcpy(name0, name);
 
    Block* b = createBlock(name0);
 
    char* properties = strtok(0, "<");
    if (properties == 0) {
        free(str0);
        return b;
    }
 
    char* property = strtok(properties, "=,");
    char* key = 0;
    char* value = 0;
    while (property != 0) {
        if (key == 0) {
            key = property;
        } else {
            int l = strlen(property);
            value = property;
 
            if (value[l - 1] == '>') {
                value[l - 1] = '\0';
            }
 
            Block_setProperty(b, key, value);
 
            key = 0;
            value = 0;
        }
 
        property = strtok(0, "=,");
    }
 
    free(str0);
    return b;
}
 
typedef struct LevelObject2D {
 
    Block* block;
 
    Coordinate2D* coordinate;
} LevelObject2D;
 
LevelObject2D* createLevelObject2D(Block* block, Coordinate2D* coordinate) {
    LevelObject2D* o = (LevelObject2D*) malloc(sizeof(LevelObject2D));
    o->block = block;
    o->coordinate = coordinate;
    return o;
}
 
char* LevelObject2D_toString(LevelObject2D* object) {
    char* block = Block_toString(object->block);
    char* coordinate = Coordinate2D_toString(object->coordinate);
 
    char* str = (char*) malloc(strlen(block) + strlen(coordinate) + 3);
    sprintf(str, "%s: %s", block, coordinate);
 
    return str;
}
 
LevelObject2D* LevelObject2D_fromString(char* str) {
    char* blockStr = strtok(str, ":");
    char* coordinateStr = strtok(0, ":");
 
    Block* block = Block_fromString(blockStr);
    Coordinate2D* coordinate = Coordinate2D_fromString(coordinateStr);
 
    return createLevelObject2D(block, coordinate);
}
 
typedef struct LevelObject3D {
 
    Block* block;
 
    Coordinate3D* coordinate;
} LevelObject3D;
 
LevelObject3D* createLevelObject3D(Block* block, Coordinate3D* coordinate) {
    LevelObject3D* o = (LevelObject3D*) malloc(sizeof(LevelObject3D));
    o->block = block;
    o->coordinate = coordinate;
    return o;
}
 
char* LevelObject3D_toString(LevelObject3D* object) {
    char* block = Block_toString(object->block);
    char* coordinate = Coordinate3D_toString(object->coordinate);
 
    char* str = (char*) malloc(strlen(block) + strlen(coordinate) + 3);
    sprintf(str, "%s: %s", block, coordinate);
 
    return str;
}
 
LevelObject3D* LevelObject3D_fromString(char* str) {
    char* blockStr = strtok(str, ":");
    char* coordinateStr = strtok(0, ":");
 
    Block* block = Block_fromString(blockStr);
    Coordinate3D* coordinate = Coordinate3D_fromString(coordinateStr);
 
    return createLevelObject3D(block, coordinate);
}
 
#endif