Adding terrain definition json and array of maps.

include/l3tde/overworld.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <l3tde/map/terrain.h>
+
+typedef struct {
+    L3TDEMapTerrainPtr *terrains;
+    size_t terrains_len;
+    char **map_files;
+    size_t map_files_len;
+} L3TDEOverworld;
+
+typedef L3TDEOverworld * L3TDEOverworldPtr;
+
+L3TDEOverworldPtr
+l3tde_overworld_create ();

meson.build

@@ -4,10 +4,12 @@ inc = include_directories('include')
 
 l3tdedeps = [
     dependency('ncurses'),
+    dependency('json-glib-1.0')
 ]
 
 sources = [
     'src/main.c',
+    'src/overworld.c',
     'src/game.c',
     'src/map.c',
     'src/map/warp.c',
@@ -20,10 +22,15 @@ sources = [
 link_arguments = [
 ]
                         
+prefix = get_option('prefix')
+
 executable('l3tde',
     sources,
     dependencies : l3tdedeps,
     include_directories : inc,
     install : true,
-    link_args : link_arguments
+    link_args : link_arguments,
+    c_args: '-DRESOURCES_PATH="'+prefix+'/share/l3tde"'
 )
+
+install_data('resources/terrains.json', 'resources/maps.json')

resources/maps.json

@@ -0,0 +1,3 @@
+[
+    "all_green.json"
+]

resources/terrains.json

@@ -0,0 +1,8 @@
+[
+    {
+        "name": "grass",
+        "symbol": ".",
+        "foreground": "black",
+        "background": "green"
+    }
+]

src/game.c

@@ -5,6 +5,7 @@
 
 #include <l3tde/game.h>
 #include <l3tde/map.h>
+#include <l3tde/overworld.h>
 
 static L3TDEMapPtr
 l3tde_game_create_default_map (void);
@@ -38,7 +39,7 @@ void
 l3tde_game_loop (L3TDEGamePtr game) {
     int input;
     while (1) {
-        clear ();
+        erase ();
         l3tde_game_render_game (game);
         input = getch ();
         bool end_game = 0;
@@ -92,7 +93,6 @@ l3tde_game_render_game (L3TDEGamePtr game) {
 
     l3tde_game_render_game_get_start_nodes (game,
             max_x, max_y, &start_node_x, &start_node_y);
-    fprintf (stderr, "%ld %ld\n", start_node_x, start_node_y);
 
     max_node_x = start_node_x + max_x;
     max_node_y = start_node_y + max_y;
@@ -179,15 +179,14 @@ static L3TDEMapPtr
 l3tde_game_create_default_map (void) {
     L3TDEMapNodePtr **nodes;
     L3TDEMapHeaderPtr header;
-    L3TDEMapTerrainPtr terrain;
+    L3TDEOverworldPtr overworld = l3tde_overworld_create ();
+    L3TDEMapTerrainPtr *terrains = overworld->terrains; 
     L3TDEMapPtr map;
 
-    const char *terrain_name = "grass";
     const char *header_name = "all_green";
     const char *header_description = "This is dummy map where all is green.";
 
     size_t nodes_len = 200;
-    size_t terrain_name_len = strlen (terrain_name);
     size_t header_name_len = strlen (header_name);
     size_t header_descrition_len = strlen (header_description);
 
@@ -197,14 +196,11 @@ l3tde_game_create_default_map (void) {
             header_name, header_name_len, 
             header_description, header_descrition_len); 
 
-    terrain = l3tde_map_terrain_create (
-            terrain_name, terrain_name_len, '.', COLOR_GREEN, 0);
-
     for (int i = 0; i < nodes_len; i++) {
         nodes[i] = malloc (sizeof **nodes * nodes_len);
         L3TDEMapNodePtr *y_nodes = nodes[i];
         for (int j = 0; j < nodes_len; j++) {
-            y_nodes[j] = l3tde_map_node_create (terrain,
+            y_nodes[j] = l3tde_map_node_create (terrains[0],
                     L3TDE_MAP_NODE_NAVIGATION_WALKABLE);
         }
     }

src/overworld.c

@@ -0,0 +1,180 @@
+#include <stdlib.h>
+#include <ncurses.h>
+
+#include <json-glib/json-glib.h>
+
+#include <l3tde/util/string.h>
+#include <l3tde/overworld.h>
+#include <l3tde/map/terrain.h>
+
+#define TERRAINS_PATH "/terrains.json"
+#define MAPS_PATH "/maps"
+#define MAPS_JSON "/maps.json"
+
+static short
+l3tde_overworld_string_to_color (const char *color);
+static char **
+l3tde_overworld_get_maps (size_t *maps_len_out);
+static L3TDEMapTerrainPtr *
+l3tde_overworld_load_terrains (size_t *terrains_len_out);
+
+L3TDEOverworldPtr
+l3tde_overworld_create () {
+    L3TDEOverworldPtr self = malloc (sizeof *self);
+    char **map_files = NULL;
+    size_t map_files_len = 0;
+    size_t terrains_len = 0;
+    L3TDEMapTerrainPtr *terrains =
+        l3tde_overworld_load_terrains (&terrains_len);
+
+    map_files = l3tde_overworld_get_maps (&map_files_len);
+
+    self->terrains = terrains;
+    self->terrains_len = terrains_len;
+
+    self->map_files = map_files;
+    self->map_files_len = map_files_len;
+
+    return self;
+}
+
+static char **
+l3tde_overworld_get_maps (size_t *maps_len_out) {
+    size_t array_maps_len = 0;
+
+    GError *error = NULL;
+
+    JsonParser *parser = NULL; 
+    JsonNode *root = NULL;
+    JsonArray *array_maps = NULL;
+    char **return_value = NULL;
+    size_t maps_len;
+
+    parser = json_parser_new ();
+    json_parser_load_from_file (parser, RESOURCES_PATH
+            MAPS_JSON, &error);
+    if (error) {
+        g_error ("Unable to read %s.", RESOURCES_PATH
+                MAPS_JSON);
+        g_clear_error (&error);
+        goto cleanup_l3tde_overworld_get_maps;
+    }
+    root = json_parser_get_root (parser);
+    if (!JSON_NODE_HOLDS_ARRAY (root)) {
+        g_error (RESOURCES_PATH MAPS_JSON
+                " doesn't hold an array.");
+        goto cleanup_l3tde_overworld_get_maps;
+    }
+    array_maps = json_node_get_array (root);
+    array_maps_len = json_array_get_length (array_maps);
+
+    for (size_t i = 0; i < array_maps_len; i++) {
+        const char *path = json_array_get_string_element (
+                array_maps, i);
+        maps_len = i+1;
+        return_value = realloc (return_value, sizeof
+                *return_value * maps_len);
+        return_value[i] = copy_string (path, strlen(path));
+    }
+cleanup_l3tde_overworld_get_maps:
+    if (parser) {
+        g_clear_object (&parser);
+    }
+    if (maps_len_out) {
+        *maps_len_out = maps_len;
+    }
+    return return_value;
+}
+
+static L3TDEMapTerrainPtr *
+l3tde_overworld_load_terrains (size_t *terrains_len_out) {
+    size_t terrains_len;
+
+    GError *error = NULL;
+
+    L3TDEMapTerrainPtr *terrains = NULL;
+    JsonParser *parser = NULL; 
+    JsonNode *root = NULL;
+    JsonArray *json_array_terrains = NULL;
+
+    parser = json_parser_new ();
+    json_parser_load_from_file (parser, 
+            RESOURCES_PATH TERRAINS_PATH, &error);
+    if (error) {
+        g_error ("Unable to read %s: %s\n",
+                RESOURCES_PATH TERRAINS_PATH, error->message);
+        g_clear_error (&error);
+        goto cleanup_l3tde_overworld_load_terrains;
+    }
+    root = json_parser_get_root (parser);
+    if (!JSON_NODE_HOLDS_ARRAY (root)) {
+        g_error ("Terrains json doesn't hold an array as the "
+                "root node.");
+    }
+    json_array_terrains = json_node_get_array (root);
+    terrains_len = json_array_get_length
+        (json_array_terrains); 
+    terrains = realloc (terrains,
+            sizeof *terrains * terrains_len);
+    for (size_t i = 0; i < terrains_len; i++) {
+        JsonNode *node = json_array_get_element
+            (json_array_terrains, i);
+        if (!JSON_NODE_HOLDS_OBJECT (node)) {
+            g_error ("Terrain %ld is not a hash.", i);
+            goto cleanup_l3tde_overworld_load_terrains;
+        }
+        JsonObject *object = json_node_get_object (node);
+        const char *name = json_object_get_string_member (
+                object, "name");
+        const char *symbol = json_object_get_string_member (
+                object, "symbol");
+        const char *foreground =
+            json_object_get_string_member (object,
+                    "foreground");
+        const char *background =
+            json_object_get_string_member (object,
+                    "background");
+        if (strlen (symbol) > 1 || strlen (symbol) < 1) {
+            g_error ("Symbol for terrain %ld is not valid.", i);
+            goto cleanup_l3tde_overworld_load_terrains;
+        }
+        char symbol_as_char = symbol[0];
+        terrains[i] = l3tde_map_terrain_create (name,
+                strlen(name),
+                symbol_as_char,
+                l3tde_overworld_string_to_color (foreground),
+                l3tde_overworld_string_to_color (background));
+    }
+cleanup_l3tde_overworld_load_terrains:
+    if (parser) {
+        g_clear_object (&parser);
+    }
+    if (terrains_len_out) {
+        *terrains_len_out = terrains_len;
+    }
+    return terrains;
+}
+
+static short
+l3tde_overworld_string_to_color (const char *color) {
+    if (!strcmp (color, "black")) {
+        return COLOR_BLACK;
+    } else if (!strcmp (color, "red")) {
+        return COLOR_RED;
+    } else if (!strcmp (color, "green")) {
+        return COLOR_GREEN;
+    } else if (!strcmp (color, "yellow")) {
+        return COLOR_YELLOW;
+    } else if (!strcmp (color, "blue")) {
+        return COLOR_BLUE;
+    } else if (!strcmp (color, "magenta")) {
+        return COLOR_MAGENTA;
+    } else if (!strcmp (color, "cyan")) {
+        return COLOR_CYAN;
+    } else if (!strcmp (color, "white")) {
+        return COLOR_WHITE;
+    }
+    g_error ("This color is not known.");
+    // Defaulting to black if error.
+    return COLOR_BLACK;
+}