timesynk/data.c

/****** data.c
  This file contains the functions for loading Data, be they Tiles or otherwise, from text data into TileData/TileSetData/Data structures. Additionally are defined functions for populating TileData into *Tile structures (as would be used from map generation or spawning operations).
******/
#include <stdlib.h>
#include <string.h>
#include "data.h"
/**** loadDataFromMemory
  Loads given data from memory into a Data struct, also populating TileSetData and TileData structs.

****/
struct Data *loadDataFromMemory(char *memory, int size) {
  struct Data *data = malloc(sizeof(struct Data));
  data->size = SET_SIZE;
  data->id = malloc(sizeof(int)*SET_SIZE);
  data->set = malloc(sizeof(struct TileSetData*)*SET_SIZE);
  memset(data->set, 0, sizeof(struct TileSetData*)*SET_SIZE);
  int offset = 0;
  int depth = 0; // used to manage position!
  data->set_count = 0;
  while (offset <= size) {
    if (memory[offset] == '{') {
      depth++;
      offset++; // skip that bracket
      if (depth == 1) {
        // now we get our tileset's id
        char temp_string[31];
        int temp_offset = offset-1;
        int temp_offset_2 = 0;
        while (memory[temp_offset] != '\n' && temp_offset > 0) {
          temp_offset--;
        }
        while (memory[temp_offset] != '{') {
          temp_string[temp_offset_2++] = memory[temp_offset++];
        }
        temp_string[temp_offset_2] = '\0';

        int tileset_id = atoi(temp_string);
        // resize Data if tileset's id is greater than our size
        if (tileset_id > data->size) {
          data->size += tileset_id-data->size;
          void *ret;
          ret = realloc(data->id, sizeof(int)*data->size);
          ret = realloc(data->set, sizeof(struct TileSetData*)*data->size);
        }
        data->set[tileset_id] = loadTileSetData(memory, &offset, &depth);
        data->set_count++;
      }
    } else if (memory[offset] == '}') {
      depth--;
    }
    offset++;
  }
  return data;
}

struct TileSetData *loadTileSetData(char *memory, int *offset, int *depth) {
  struct TileSetData *set_data = malloc(sizeof(struct TileSetData));
  set_data->size = SET_SIZE; // default of 32
  set_data->id = malloc(sizeof(int)*SET_SIZE);
  set_data->tile = malloc(sizeof(struct TileData*)*SET_SIZE);
  /* populate Tiles! */
  while (*depth != 0) {
    if (memory[*offset] == '{') {
      *offset = *offset + 1; //skip the bracket
      *depth = *depth + 1;
      if (*depth == 2) {
        // now we get our tileset's id
        char temp_string[31];
        int temp_offset = *offset-1;
        int temp_offset_2 = 0;
        while (memory[temp_offset] != '\n' && temp_offset > 0) {
          temp_offset--;
        }
        while (memory[temp_offset] != '{') {
          temp_string[temp_offset_2++] = memory[temp_offset++];
        }
        temp_string[temp_offset_2] = '\0';

        int tile_id = atoi(temp_string);
        // resize Data if tileset's id is greater than our size
        if (tile_id > set_data->size) {
          set_data->size += tile_id-set_data->size;
          void *ret;
          ret = realloc(set_data->id, sizeof(int)*set_data->size);
          ret = realloc(set_data->tile, sizeof(struct TileData*)*set_data->size);
        }
        set_data->tile[tile_id] = loadTileData(memory, offset, depth);
        set_data->tile_count++;
      }

    } else if (memory[*offset] == '}') {
      *depth = *depth - 1;
    }
    *offset = *offset + 1;
  }
  return set_data;
}

struct TileData *loadTileData(char *memory, int *offset, int *depth) {
  struct TileData *tile_data = malloc(sizeof(struct TileData));
  tile_data->count = 0;
  tile_data->length = 8;
  tile_data->keys = malloc(sizeof(char*)*8);
  tile_data->size = malloc(sizeof(char*)*8);
  tile_data->values = malloc(sizeof(void*)*8);

  char var_name[32]; // max 32 chars for var name
  char var_value[256]; // max 256 chars for value

  int i = 0;

  short mode = 0;
  while(*depth > 1) {
    switch (memory[*offset]) {
      case '{':
        *depth = *depth + 1;
        break;
      case '}':
        *depth = *depth - 1;
        break;
      case ' ':
        if (mode == 1) {
          var_name[i] = '\0';
          i = 0;
          mode = 2;
        } else if (mode == 2) {
          var_value[i++] = memory[*offset];
        }
        break;
      case '\n':
        var_value[i] = '\0';
        if (mode == 2) {
          // generate key=>value pairs and parse value into types (string, int, float)
          printf("%s=>%s\n", var_name, var_value);
        }
        i = 0;
        mode = 0;
        break;
      default:
        if (mode == 1) {
          var_name[i++] = memory[*offset];
        } else if (mode == 2) {
          var_value[i++] = memory[*offset];
        } else if (mode == 0) {
          mode = 1;
          var_name[i++] = memory[*offset];
        }
        break;
    }
    if (*depth <= 1)
      break;
    *offset = *offset + 1;
  }
  return tile_data;
}

int setTileDataSize(struct TileData *tile_data, int size) {
  tile_data->length = size;
  void *ret;
  ret = realloc(tile_data->keys, sizeof(char*)*size);
  if (ret == NULL)
    return 1;
  ret = realloc(tile_data->size, sizeof(char*)*size);
  if (ret == NULL)
    return 2;
  ret = realloc(tile_data->values, sizeof(void*)*size);
  if (ret == NULL)
    return 3;
  if (tile_data->count > size)
    tile_data->count = size;
  return 0;
}