331 lines
10 KiB
C
331 lines
10 KiB
C
#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>
|
|
#include <l3tde/map.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);
|
|
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 (void) {
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
}
|