Adding maps as json definitions.

include/l3tde/overworld.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <l3tde/map/terrain.h>
+#include <l3tde/map.h>
 
 typedef struct {
     L3TDEMapTerrainPtr *terrains;
@@ -13,3 +14,7 @@ typedef L3TDEOverworld * L3TDEOverworldPtr;
 
 L3TDEOverworldPtr
 l3tde_overworld_create ();
+
+L3TDEMapPtr
+l3tde_overworld_get_map (L3TDEOverworldPtr self,
+        size_t map_number);

meson.build

@@ -23,6 +23,7 @@ link_arguments = [
 ]
                         
 prefix = get_option('prefix')
+datadir = get_option('datadir')
 
 executable('l3tde',
     sources,
@@ -34,3 +35,5 @@ executable('l3tde',
 )
 
 install_data('resources/terrains.json', 'resources/maps.json')
+install_data('resources/maps/all_green.json',
+        install_dir : datadir + '/l3tde/maps/')

src/game.c

@@ -226,41 +226,8 @@ l3tde_game_create_default_game (void) {
 
 static L3TDEMapPtr
 l3tde_game_create_default_map (void) {
-    L3TDEMapNodePtr **nodes;
-    L3TDEMapHeaderPtr header;
     L3TDEOverworldPtr overworld = l3tde_overworld_create ();
-    L3TDEMapTerrainPtr *terrains = overworld->terrains; 
-    L3TDEMapPtr map;
-
-    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 header_name_len = strlen (header_name);
-    size_t header_descrition_len = strlen (header_description);
-
-    nodes = malloc (sizeof *nodes * nodes_len);
-
-    header = l3tde_map_header_create (
-            header_name, header_name_len, 
-            header_description, header_descrition_len); 
-
-    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++) {
-            if (rand() % 50 > 45) {
-                y_nodes[j] = l3tde_map_node_create (
-                        terrains[1], 0);
-            } else {
-                y_nodes[j] = l3tde_map_node_create (
-                        terrains[0],
-                        L3TDE_MAP_NODE_NAVIGATION_WALKABLE);
-            }
-        }
-    }
-
-    map = l3tde_map_create (header, nodes, nodes_len, nodes_len, NULL, 0);
+    L3TDEMapPtr map = l3tde_overworld_get_map (overworld, 0);
     return map;
 }
 

src/overworld.c

@@ -6,9 +6,10 @@
 #include <l3tde/util/string.h>
 #include <l3tde/overworld.h>
 #include <l3tde/map/terrain.h>
+#include <l3tde/map.h>
 
 #define TERRAINS_PATH "/terrains.json"
-#define MAPS_PATH "/maps"
+#define MAPS_PATH "/maps/"
 #define MAPS_JSON "/maps.json"
 
 static short
@@ -17,6 +18,16 @@ static char **
 l3tde_overworld_get_maps (size_t *maps_len_out);
 static L3TDEMapTerrainPtr *
 l3tde_overworld_load_terrains (size_t *terrains_len_out);
+static L3TDEMapHeaderPtr
+l3tde_overworld_get_header_from_map_json (
+        JsonObject *map_object);
+static L3TDEMapNodePtr **
+l3tde_overworld_get_nodes_from_map_json (
+        L3TDEOverworldPtr self, JsonObject *map_object,
+        size_t *nodes_x_len_out, size_t *nodes_y_len_out);
+static L3TDEMapNodePtr *
+l3tde_overworld_iterate_nodes_x_axys (
+        L3TDEOverworldPtr self, JsonArray *nodes_x_axys);
 
 L3TDEOverworldPtr
 l3tde_overworld_create () {
@@ -38,6 +49,145 @@ l3tde_overworld_create () {
     return self;
 }
 
+L3TDEMapPtr
+l3tde_overworld_get_map (L3TDEOverworldPtr self,
+        size_t map_number) {
+    GError *error = NULL;
+    JsonParser *parser = NULL; 
+    JsonNode *root = NULL;
+    JsonObject *map_object = NULL;
+
+    L3TDEMapHeaderPtr header = NULL;
+    L3TDEMapPtr map = NULL;
+    L3TDEMapNodePtr **nodes = NULL;
+
+    char **map_files = self->map_files;
+    char *current_map_str = map_files[map_number];
+    char *current_map_path = NULL;
+    size_t current_map_path_len = 0;
+    size_t nodes_len;
+    size_t nodes_x_len;
+
+    current_map_path_len = snprintf (NULL, 0, "%s%s%s",
+            RESOURCES_PATH, MAPS_PATH, current_map_str) + 1;
+    current_map_path = malloc (sizeof *current_map_path * current_map_path_len);
+    snprintf (current_map_path,
+            current_map_path_len, "%s%s%s", RESOURCES_PATH,
+            MAPS_PATH, current_map_str);
+
+    parser = json_parser_new ();
+    json_parser_load_from_file (parser,
+           current_map_path, &error);
+    if (error) {
+        g_error ("%s", error->message);
+    }
+    root = json_parser_get_root (parser);
+
+    map_object = json_node_get_object (root);
+    header = l3tde_overworld_get_header_from_map_json
+        (map_object);
+    nodes = l3tde_overworld_get_nodes_from_map_json (self,
+            map_object, &nodes_x_len, &nodes_len);
+    if (!nodes) {
+        g_error ("Nodes is null.");
+        return NULL;
+    }
+    map = l3tde_map_create (header, nodes, nodes_x_len,
+            nodes_len, NULL, 0);
+    return map;
+}
+
+static L3TDEMapNodePtr **
+l3tde_overworld_get_nodes_from_map_json (
+        L3TDEOverworldPtr self, JsonObject *map_object,
+        size_t *nodes_x_len_out, size_t *nodes_y_len_out) {
+    JsonArray *nodes_array;
+    L3TDEMapNodePtr **nodes = NULL;
+    size_t nodes_array_y_len = 0;
+
+    if (!nodes_x_len_out || !nodes_y_len_out) {
+        g_error ("The output size of the array must be a not "
+                "null pointer.");
+        return NULL;
+    }
+
+    *nodes_x_len_out = json_object_get_int_member (
+            map_object, "nodes_x_len");
+    *nodes_y_len_out = json_object_get_int_member (
+            map_object, "nodes_y_len");
+    nodes_array = json_object_get_array_member (map_object,
+            "nodes");
+    nodes_array_y_len = json_array_get_length (nodes_array);
+
+    if (*nodes_y_len_out != nodes_array_y_len) {
+        g_error ("The map has an incorrect node size in the "
+                " y axys unable to load. %ld", nodes_array_y_len);
+        return NULL;
+    }
+
+    for (unsigned int i = 0; i < nodes_array_y_len; i++) {
+        JsonArray *nodes_x_array = json_array_get_array_element
+            (nodes_array, i);
+        unsigned int nodes_x_array_len = json_array_get_length
+            (nodes_x_array);
+        if (nodes_x_array_len != *nodes_x_len_out) {
+            g_error ("The map has an incorrect node size in "
+                    " the x axys.");
+            return NULL;
+        }
+        nodes = realloc (nodes, sizeof *nodes * (i+1));
+        nodes[i] = l3tde_overworld_iterate_nodes_x_axys (
+                self,
+                nodes_x_array);
+        if (!nodes[i]) {
+            return NULL;
+        }
+    }
+    return nodes;
+}
+
+static L3TDEMapNodePtr *
+l3tde_overworld_iterate_nodes_x_axys (
+        L3TDEOverworldPtr self, JsonArray *nodes_x_axys) {
+    L3TDEMapNodePtr *nodes = NULL;
+    unsigned int nodes_x_array_len = json_array_get_length
+        (nodes_x_axys);
+    for (unsigned int i = 0; i < nodes_x_array_len; i++) {
+        JsonObject *node_object = json_array_get_object_element
+            (nodes_x_axys, i);
+        size_t terrain_number = json_object_get_int_member 
+            (node_object, "terrain");
+        size_t navigation = json_object_get_int_member (
+                node_object, "navigation");
+        if (!(terrain_number < self->terrains_len)) {
+            g_error ("Unexpected terrain number.");
+            return NULL;
+        }
+        L3TDEMapTerrainPtr terrain =
+            self->terrains[terrain_number];
+        nodes = realloc (nodes, sizeof *nodes * (i+1));
+        nodes[i] = l3tde_map_node_create (terrain,
+                (L3TDEMapNodeNavigation) navigation);
+    }
+    return nodes;
+}
+
+static L3TDEMapHeaderPtr
+l3tde_overworld_get_header_from_map_json (
+        JsonObject *map_object) {
+    const char *name;
+    const char *description;
+
+    JsonObject *header_object = json_object_get_object_member
+        (map_object, "header");
+    name = json_object_get_string_member (header_object,
+            "name");
+    description = json_object_get_string_member (header_object,
+            "description");
+    return l3tde_map_header_create (name, strlen (name),
+            description, strlen (description));
+}
+
 static char **
 l3tde_overworld_get_maps (size_t *maps_len_out) {
     size_t array_maps_len = 0;