path: root/src/main.c

#include "cJSON.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>

#define JSON_GET(j, s)                                                         \
  cJSON *const s = cJSON_GetObjectItem(j, #s);                                 \
  if (s == NULL) {                                                             \
    fprintf(stderr, #s " not found\n");                                        \
    return -1;                                                                 \
  }

#define JSON_GET_STRING(j, s)                                                  \
  JSON_GET(j, s);                                                              \
  if (!cJSON_IsString(s)) {                                                    \
    fprintf(stderr, #s " is no string\n");                                     \
    return -1;                                                                 \
  }

#define JSON_GET_OPT_STRING(j, s)                                              \
  cJSON *const s = cJSON_GetObjectItem(j, #s);                                 \
  if (s != NULL && !cJSON_IsString(s)) {                                       \
    fprintf(stderr, #s " is no string\n");                                     \
    return -1;                                                                 \
  }

#define JSON_GET_BOOL(j, s)                                                    \
  JSON_GET(j, s);                                                              \
  if (!cJSON_IsBool(s)) {                                                      \
    fprintf(stderr, #s " is no bool\n");                                       \
    return -1;                                                                 \
  }

#define JSON_GET_ARRAY(j, s)                                                   \
  JSON_GET(j, s);                                                              \
  if (!cJSON_IsArray(s)) {                                                     \
    fprintf(stderr, #s " is no array\n");                                      \
    return -1;                                                                 \
  }                                                                            \
  const int s##_size = cJSON_GetArraySize(s);                                  \
  (void)s##_size

static int process_layer(cJSON *json) {
  JSON_GET_STRING(json, type);
  JSON_GET_STRING(json, name);
  JSON_GET_OPT_STRING(json, class);
  JSON_GET(json, opacity);
  JSON_GET(json, visible);
  cJSON *const parallaxx = cJSON_GetObjectItem(json, "parallaxx");
  cJSON *const parallaxy = cJSON_GetObjectItem(json, "parallaxy");

  printf("{\"%s\",%s%s%s,'%c',%f,%d,%f,%f,", name->valuestring,
         class ? "\"" : "", class ? class->valuestring : "0", class ? "\"" : "",
         type->valuestring[0], opacity->valuedouble, cJSON_IsTrue(visible),
         cJSON_IsNumber(parallaxx) ? parallaxx->valuedouble : 1.0,
         cJSON_IsNumber(parallaxy) ? parallaxy->valuedouble : 1.0);

  return 0;
}

static int process_imagelayer(cJSON *json) {
  if (process_layer(json))
    return -1;
  JSON_GET_STRING(json, image);
  JSON_GET(json, offsetx);
  JSON_GET(json, offsety)

  printf(".imagelayer={\"%s\",%d,%d}},", image->valuestring, offsetx->valueint,
         offsety->valueint);

  return 0;
}

static int process_tilelayer(cJSON *json) {
  if (process_layer(json))
    return -1;
  JSON_GET_ARRAY(json, data);

  printf(".tilelayer={(const unsigned int[]){");
  cJSON *tile;
  cJSON_ArrayForEach(tile, data) printf("%u,", (unsigned)tile->valuedouble);
  printf("}}},");

  return 0;
}

static int process_property(cJSON *json) {
  JSON_GET_STRING(json, name);
  JSON_GET_STRING(json, type);
  printf("{\"%s\",\"%s\",", name->valuestring, type->valuestring);

  if (type->valuestring[0] == 's' || type->valuestring[0] == 'c') {
    JSON_GET_STRING(json, value);
    printf("\"%s\",0},", value->valuestring);
  } else if (type->valuestring[0] == 'b') {
    JSON_GET_BOOL(json, value);
    printf("\"%s\",%d},", value->valueint ? "true" : "false", value->valueint);
  } else {
    JSON_GET(json, value);
    printf("\"%f\",%f},", value->valuedouble, value->valuedouble);
  }

  return 0;
}

static int process_object(cJSON *json) {
  JSON_GET_STRING(json, name);
  JSON_GET_STRING(json, type);
  JSON_GET(json, id);
  cJSON *const tile = cJSON_GetObjectItem(json, "gid");
  JSON_GET(json, x);
  JSON_GET(json, y);
  JSON_GET(json, width);
  JSON_GET(json, height);
  JSON_GET(json, rotation);
  JSON_GET(json, visible);
  printf("{\"%s\",\"%s\",%d,%d,%d,%d,%d,%d,%f,%d", name->valuestring,
         type->valuestring, id->valueint, tile ? tile->valueint : 0,
         x->valueint, y->valueint, width->valueint, height->valueint,
         rotation->valuedouble, cJSON_IsTrue(visible));

  cJSON *properties = cJSON_GetObjectItem(json, "properties");
  if (!cJSON_IsArray(properties) || cJSON_GetArraySize(properties) == 0)
    printf(",0,0");
  else {
    printf(",%d,(const Tiled2cProperty[]){", cJSON_GetArraySize(properties));
    cJSON *property;
    cJSON_ArrayForEach(property, properties) {
      if (process_property(property))
        return -1;
    }
    printf("}");
  }

  printf("},");
  return 0;
}

static int process_map(const char *word, const char *path, cJSON *json) {
  JSON_GET(json, width);
  JSON_GET(json, height);
  JSON_GET(json, tilewidth);
  JSON_GET(json, tileheight);
  JSON_GET_ARRAY(json, layers);

  int numlayers = 0;
  cJSON *layer;
  cJSON_ArrayForEach(layer, layers) {
    JSON_GET_STRING(layer, type);
    numlayers += (type->valuestring[0] == 't' || type->valuestring[0] == 'i');
  }

  printf("#include \"tiled2c.h\"\n"
         "const Tiled2cMap %s={\"%s\",%d,%d,%d,%d,"
         "%d,(const Tiled2cLayer[]){",
         word, path, width->valueint, height->valueint, tilewidth->valueint,
         tileheight->valueint, numlayers);
  cJSON_ArrayForEach(layer, layers) {
    JSON_GET_STRING(layer, type);
    switch (type->valuestring[0]) {
    case 'i': /* imagelayer */
      if (process_imagelayer(layer) < 0)
        return -1;
      break;
    case 'o': /* objectgroup */
      break;
    case 't': /* tilelayer */
      if (process_tilelayer(layer) < 0)
        return -1;
      break;
    default:
      fprintf(stderr, "unknown layer type '%s'\n", type->valuestring);
      return -1;
    }
  }
  int numobjects = 0;
  cJSON_ArrayForEach(layer, layers) {
    JSON_GET_STRING(layer, type);
    if (type->valuestring[0] != 'o')
      continue;
    JSON_GET_ARRAY(layer, objects);
    numobjects += cJSON_GetArraySize(objects);
  }
  printf("},%d,(const Tiled2cObject[]){", numobjects);
  cJSON_ArrayForEach(layer, layers) {
    JSON_GET_STRING(layer, type);
    if (type->valuestring[0] != 'o')
      continue;
    JSON_GET_ARRAY(layer, objects);
    cJSON *object;
    cJSON_ArrayForEach(object, objects) {
      if (process_object(object) < 0)
        return -1;
    }
  }
  printf("}};\n");
  return 0;
}

static int process_frame(cJSON *json) {
  JSON_GET(json, duration);
  JSON_GET(json, tileid);
  printf("{%d,%d},", duration->valueint, tileid->valueint);
  return 0;
}

static int process_animation(cJSON *json) {
  printf("%d,(const Tiled2cFrame[]){", cJSON_GetArraySize(json));
  cJSON *frame;
  cJSON_ArrayForEach(frame, json) if (process_frame(frame) < 0) return -1;
  printf("}");
  return 0;
}

static int process_tile(cJSON *json) {
  JSON_GET(json, id);
  cJSON *const type = cJSON_GetObjectItem(json, "type");
  if (type != NULL && !cJSON_IsString(type)) {
    fprintf(stderr, "type is no string\n");
    return -1;
  }
  cJSON *const proba = cJSON_GetObjectItem(json, "probability");
  cJSON *const anim = cJSON_GetObjectItem(json, "animation");
  if (anim != NULL && !cJSON_IsArray(anim)) {
    fprintf(stderr, "animation is no array\n");
    return -1;
  }
  printf("{%d,%s%s%s,%f,", id->valueint, (type != NULL) ? "\"" : "",
         (type != NULL) ? type->valuestring : "0", (type != NULL) ? "\"" : "",
         (proba != NULL) ? proba->valuedouble : 0.0);
  if (anim == NULL)
    printf("0,0");
  else if (process_animation(anim) < 0)
    return -1;

  cJSON *properties = cJSON_GetObjectItem(json, "properties");
  if (!cJSON_IsArray(properties))
    printf(",0,0");
  else {
    printf(",%d,(const Tiled2cProperty[]){", cJSON_GetArraySize(properties));
    cJSON *property;
    cJSON_ArrayForEach(property, properties) {
      if (process_property(property))
        return -1;
    }
    printf("}");
  }

  cJSON *objectgroup = cJSON_GetObjectItem(json, "objectgroup");
  if (!cJSON_IsObject(objectgroup))
    printf(",0,0");
  else {
    JSON_GET_ARRAY(objectgroup, objects);
    printf(",%d,(const Tiled2cObject[]){", cJSON_GetArraySize(objects));
    cJSON *object;
    cJSON_ArrayForEach(object, objects) {
      if (process_object(object) < 0)
        return -1;
    }
    printf("}");
  }

  printf("},");
  return 0;
}

static int process_tileset(const char *word, cJSON *json) {
  JSON_GET_STRING(json, name);
  JSON_GET_STRING(json, image);
  cJSON *tiles = cJSON_GetObjectItem(json, "tiles");
  if (tiles != NULL && !cJSON_IsArray(tiles)) {
    fprintf(stderr, "tiles is no array\n");
    return -1;
  }
  JSON_GET(json, imagewidth);
  JSON_GET(json, imageheight);
  JSON_GET(json, tilewidth);
  JSON_GET(json, tileheight);
  JSON_GET(json, margin);
  JSON_GET(json, columns);
  JSON_GET(json, tilecount);

  printf("#include \"tiled2c.h\"\n"
         "const Tiled2cSet %s={\"%s\",\"%s\",%d,%d,%d,%d,%d,%d,%d,"
         "%d,(const Tiled2cTile[]){",
         word, name->valuestring, image->valuestring, imagewidth->valueint,
         imageheight->valueint, tilewidth->valueint, tileheight->valueint,
         margin->valueint, columns->valueint, tilecount->valueint,
         (tiles != NULL) ? cJSON_GetArraySize(tiles) : 0);

  if (tiles != NULL) {
    cJSON *tile;
    cJSON_ArrayForEach(tile, tiles) if (process_tile(tile)) return -1;
  }
  printf("}};\n");
  return 0;
}

char *drain(FILE *fp, long *size) {
  if (fseek(fp, 0, SEEK_END) < 0) {
    perror("drain:SEEK_END");
    return NULL;
  }
  *size = ftell(fp);
  if (fseek(fp, 0, SEEK_SET) < 0) {
    perror("drain:SEEK_SET");
    return NULL;
  }
  char *const data = malloc(*size);
  if (data == NULL) {
    perror("drain:malloc");
    return NULL;
  }
  if ((long)fread(data, 1, *size, fp) != *size) {
    perror("drain:fread");
    free(data);
    return NULL;
  }
  return data;
}

static int process(const char *path, const char *name) {
  FILE *fp = fopen(path, "rb");
  if (fp == NULL) {
    perror("process:fopen");
    return -1;
  }
  long size;
  char *const content = drain(fp, &size);
  fclose(fp);
  if (content == NULL)
    return -1;

  cJSON *const json = cJSON_ParseWithLength(content, size);
  if (json == NULL) {
    fprintf(stderr, "cJSON error: %s\n", cJSON_GetErrorPtr());
    return -1;
  }

  cJSON *const type = cJSON_GetObjectItem(json, "type");
  if (type == NULL || !cJSON_IsString(type)) {
    fprintf(stderr, "type not found\n");
    return -1;
  }

  const char *const type_s = cJSON_GetStringValue(type);
  switch (type_s[0]) {
  case 'm': /* map */
    if (process_map(name, path, json) < 0)
      goto process_panic;
    break;
  case 't': /* tileset */
    if (process_tileset(name, json) < 0)
      goto process_panic;
    break;
  default:
    fprintf(stderr, "unknown type '%s'\n", type_s);
    goto process_panic;
  }

  cJSON_Delete(json);
  free(content);
  return 0;
process_panic:
  cJSON_Delete(json);
  free(content);
  return -1;
}

int main(int argc, char **argv) {
  if (argc != 3) {
    fprintf(stderr, "usage: %s <tiled .tsj or .tmj> <name>\n", argv[0]);
    return 1;
  }
  if (process(argv[1], argv[2]) < 0)
    return 1;
  return 0;
}