andrew/libakgl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Unify the library on an akgl_ namespace

Browse Source
This commit is contained in:
Andrew Kesterson
2026-05-06 23:18:42 -04:00
parent f416cb5dee
commit 359ae23414
46 changed files with 1327 additions and 1270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
src/tilemap.c
View File

@@ -13,27 +13,27 @@
#include <sdl3game/staticstring.h>
#include <sdl3game/game.h>
akerr_ErrorContext *get_json_tilemap_property(json_t *obj, char *key, char *type, json_t **dest)
akerr_ErrorContext *akgl_get_json_tilemap_property(json_t *obj, char *key, char *type, json_t **dest)
{
PREPARE_ERROR(errctx);
json_t *properties = NULL;
json_t *property = NULL;
string *tmpstr = NULL;
akgl_String *tmpstr = NULL;
int i = 0;
// This is not a generic JSON helper. It assumes we are receiving an object with a 'properties' key
// inside of it. That key is an array of objects, and each object has a name, type, and value.
FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL json obj reference");
FAIL_ZERO_RETURN(errctx, key, AKERR_NULLPOINTER, "NULL key string");
ATTEMPT {
CATCH(errctx, get_json_array_value(obj, "properties", &properties));
CATCH(errctx, akgl_get_json_array_value(obj, "properties", &properties));
for (i = 0; i < json_array_size(properties); i++) {
CATCH(errctx, get_json_array_index_object(properties, i, &property));
CATCH(errctx, get_json_string_value(property, "name", &tmpstr));
CATCH(errctx, akgl_get_json_array_index_object(properties, i, &property));
CATCH(errctx, akgl_get_json_string_value(property, "name", &tmpstr));
if ( strcmp(tmpstr->data, key) != 0 ) {
CATCH(errctx, heap_release_string(tmpstr));
CATCH(errctx, akgl_heap_release_string(tmpstr));
continue;
}
CATCH(errctx, get_json_string_value(property, "type", &tmpstr));
CATCH(errctx, akgl_get_json_string_value(property, "type", &tmpstr));
if ( strcmp(tmpstr->data, type) != 0 ) {
FAIL_BREAK(errctx, AKERR_TYPE, "Character property is present but is incorrect type");
}
@@ -42,7 +42,7 @@ akerr_ErrorContext *get_json_tilemap_property(json_t *obj, char *key, char *type
}
} CLEANUP {
if ( tmpstr != NULL ) {
IGNORE(heap_release_string(tmpstr));
IGNORE(akgl_heap_release_string(tmpstr));
}
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -51,16 +51,16 @@ akerr_ErrorContext *get_json_tilemap_property(json_t *obj, char *key, char *type
}
akerr_ErrorContext *get_json_properties_string(json_t *obj, char *key, string **dest)
akerr_ErrorContext *akgl_get_json_properties_string(json_t *obj, char *key, akgl_String **dest)
{
PREPARE_ERROR(errctx);
json_t *property;
ATTEMPT {
CATCH(errctx, get_json_tilemap_property(obj, key, "string", &property));
CATCH(errctx, heap_next_string(dest));
CATCH(errctx, string_initialize(*dest, NULL));
CATCH(errctx, get_json_string_value(property, "value", dest));
CATCH(errctx, akgl_get_json_tilemap_property(obj, key, "string", &property));
CATCH(errctx, akgl_heap_next_string(dest));
CATCH(errctx, akgl_string_initialize(*dest, NULL));
CATCH(errctx, akgl_get_json_string_value(property, "value", dest));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -68,13 +68,13 @@ akerr_ErrorContext *get_json_properties_string(json_t *obj, char *key, string **
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *get_json_properties_integer(json_t *obj, char *key, int *dest)
akerr_ErrorContext *akgl_get_json_properties_integer(json_t *obj, char *key, int *dest)
{
PREPARE_ERROR(errctx);
json_t *property = NULL;
ATTEMPT {
CATCH(errctx, get_json_tilemap_property(obj, key, "int", &property));
CATCH(errctx, get_json_integer_value(property, "value", dest));
CATCH(errctx, akgl_get_json_tilemap_property(obj, key, "int", &property));
CATCH(errctx, akgl_get_json_integer_value(property, "value", dest));
} CLEANUP {
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -82,31 +82,31 @@ akerr_ErrorContext *get_json_properties_integer(json_t *obj, char *key, int *des
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load_tilesets_each(json_t *tileset, tilemap *dest, int tsidx)
akerr_ErrorContext *akgl_tilemap_load_tilesets_each(json_t *tileset, akgl_Tilemap *dest, int tsidx)
{
PREPARE_ERROR(errctx);
string *tmpstr = NULL;
akgl_String *tmpstr = NULL;
ATTEMPT {
CATCH(errctx, get_json_integer_value((json_t *)tileset, "columns", &dest->tilesets[tsidx].columns));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "firstgid", &dest->tilesets[tsidx].firstgid));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "imageheight", &dest->tilesets[tsidx].imageheight));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "imagewidth", &dest->tilesets[tsidx].imagewidth));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "margin", &dest->tilesets[tsidx].margin));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "spacing", &dest->tilesets[tsidx].spacing));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "tilecount", &dest->tilesets[tsidx].tilecount));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "tileheight", &dest->tilesets[tsidx].tileheight));
CATCH(errctx, get_json_integer_value((json_t *)tileset, "tilewidth", &dest->tilesets[tsidx].tilewidth));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "columns", &dest->tilesets[tsidx].columns));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "firstgid", &dest->tilesets[tsidx].firstgid));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "imageheight", &dest->tilesets[tsidx].imageheight));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "imagewidth", &dest->tilesets[tsidx].imagewidth));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "margin", &dest->tilesets[tsidx].margin));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "spacing", &dest->tilesets[tsidx].spacing));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "tilecount", &dest->tilesets[tsidx].tilecount));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "tileheight", &dest->tilesets[tsidx].tileheight));
CATCH(errctx, akgl_get_json_integer_value((json_t *)tileset, "tilewidth", &dest->tilesets[tsidx].tilewidth));
CATCH(errctx, get_json_string_value((json_t *)tileset, "name", &tmpstr));
CATCH(errctx, akgl_get_json_string_value((json_t *)tileset, "name", &tmpstr));
strncpy((char *)&dest->tilesets[tsidx].name,
(char *)&tmpstr->data,
TILEMAP_MAX_TILESET_NAME_SIZE
AKGL_TILEMAP_MAX_TILESET_NAME_SIZE
);
CATCH(errctx, get_json_string_value((json_t *)tileset, "image", &tmpstr));
CATCH(errctx, akgl_get_json_string_value((json_t *)tileset, "image", &tmpstr));
snprintf((char *)&dest->tilesets[tsidx].imagefilename,
TILEMAP_MAX_TILESET_FILENAME_SIZE,
AKGL_TILEMAP_MAX_TILESET_FILENAME_SIZE,
"%s%s",
SDL_GetBasePath(),
tmpstr->data
@@ -121,7 +121,7 @@ akerr_ErrorContext *tilemap_load_tilesets_each(json_t *tileset, tilemap *dest, i
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_compute_tileset_offsets(tilemap *dest, int tilesetidx)
akerr_ErrorContext *akgl_tilemap_compute_tileset_offsets(akgl_Tilemap *dest, int tilesetidx)
{
int x_offset = 0;
int y_offset = 0;
@@ -176,7 +176,7 @@ akerr_ErrorContext *tilemap_compute_tileset_offsets(tilemap *dest, int tilesetid
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load_tilesets(tilemap *dest, json_t *root)
akerr_ErrorContext *akgl_tilemap_load_tilesets(akgl_Tilemap *dest, json_t *root)
{
PREPARE_ERROR(errctx);
FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "Received NULL tilemap pointer");
@@ -188,11 +188,11 @@ akerr_ErrorContext *tilemap_load_tilesets(tilemap *dest, json_t *root)
dest->numtilesets = 0;
ATTEMPT {
CATCH(errctx, get_json_array_value(root, "tilesets", &tilesets))
CATCH(errctx, akgl_get_json_array_value(root, "tilesets", &tilesets))
for (i = 0; i < json_array_size((json_t *)tilesets); i++) {
CATCH(errctx, get_json_array_index_object((json_t *)tilesets, i, &jstileset));
CATCH(errctx, tilemap_load_tilesets_each(jstileset, dest, i));
CATCH(errctx, tilemap_compute_tileset_offsets(dest, i));
CATCH(errctx, akgl_get_json_array_index_object((json_t *)tilesets, i, &jstileset));
CATCH(errctx, akgl_tilemap_load_tilesets_each(jstileset, dest, i));
CATCH(errctx, akgl_tilemap_compute_tileset_offsets(dest, i));
dest->numtilesets += 1;
}
} CLEANUP {
@@ -202,37 +202,37 @@ akerr_ErrorContext *tilemap_load_tilesets(tilemap *dest, json_t *root)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load_layer_object_actor(tilemap_object *curobj, json_t *layerdatavalue, int layerid)
akerr_ErrorContext *akgl_tilemap_load_layer_object_actor(akgl_TilemapObject *curobj, json_t *layerdatavalue, int layerid)
{
PREPARE_ERROR(errctx);
string *tmpstr = NULL;
actor *actorobj = NULL;
akgl_String *tmpstr = NULL;
akgl_Actor *actorobj = NULL;
curobj->type = TILEMAP_OBJECT_TYPE_ACTOR;
curobj->type = AKGL_TILEMAP_OBJECT_TYPE_ACTOR;
if ( strlen((char *)&curobj->name) == 0 ) {
FAIL_RETURN(errctx, AKERR_KEY, "Actor in tile object layer cannot have empty name");
}
ATTEMPT {
CATCH(errctx, heap_next_string(&tmpstr));
actorobj = SDL_GetPointerProperty(REGISTRY_ACTOR, (char *)&curobj->name, NULL);
CATCH(errctx, akgl_heap_next_string(&tmpstr));
actorobj = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, (char *)&curobj->name, NULL);
if ( actorobj == NULL ) {
CATCH(errctx, heap_next_actor(&actorobj));
CATCH(errctx, actor_initialize((actor *)actorobj, (char *)&curobj->name));
CATCH(errctx, get_json_properties_string((json_t *)layerdatavalue, "character", &tmpstr));
CATCH(errctx, akgl_heap_next_actor(&actorobj));
CATCH(errctx, akgl_actor_initialize((akgl_Actor *)actorobj, (char *)&curobj->name));
CATCH(errctx, akgl_get_json_properties_string((json_t *)layerdatavalue, "character", &tmpstr));
CATCH(errctx,
actor_set_character(
(actor *)actorobj,
akgl_actor_set_character(
(akgl_Actor *)actorobj,
(char *)&tmpstr->data
)
);
} else {
actorobj->refcount += 1;
}
CATCH(errctx, get_json_properties_integer((json_t *)layerdatavalue, "state", &actorobj->state));
CATCH(errctx, akgl_get_json_properties_integer((json_t *)layerdatavalue, "state", &actorobj->state));
} CLEANUP {
if ( tmpstr != NULL ) {
IGNORE(heap_release_string(tmpstr));
IGNORE(akgl_heap_release_string(tmpstr));
}
} PROCESS(errctx) {
} FINISH(errctx, true);
@@ -241,42 +241,42 @@ akerr_ErrorContext *tilemap_load_layer_object_actor(tilemap_object *curobj, json
actorobj->x = curobj->x;
actorobj->y = curobj->y;
actorobj->visible = curobj->visible;
curobj->actorptr = (actor *)actorobj;
curobj->actorptr = (akgl_Actor *)actorobj;
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load_layer_objects(tilemap *dest, json_t *root, int layerid)
akerr_ErrorContext *akgl_tilemap_load_layer_objects(akgl_Tilemap *dest, json_t *root, int layerid)
{
PREPARE_ERROR(errctx);
json_t *layerdata = NULL;
json_t *layerdatavalue = NULL;
int j;
int len;
tilemap_layer *curlayer = NULL;
tilemap_object *curobj = NULL;
string *tmpstr = NULL;
akgl_TilemapLayer *curlayer = NULL;
akgl_TilemapObject *curobj = NULL;
akgl_String *tmpstr = NULL;
FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "NULL destination tilemap reference");
FAIL_ZERO_RETURN(errctx, root, AKERR_NULLPOINTER, "NULL tilemap root reference");
ATTEMPT {
CATCH(errctx, get_json_array_value(root, "objects", &layerdata));
CATCH(errctx, akgl_get_json_array_value(root, "objects", &layerdata));
len = json_array_size((json_t *)layerdata);
curlayer = &dest->layers[layerid];
for ( j = 0; j < len; j++ ) {
CATCH(errctx, get_json_array_index_object((json_t *)layerdata, j, &layerdatavalue));
CATCH(errctx, akgl_get_json_array_index_object((json_t *)layerdata, j, &layerdatavalue));
curobj = &curlayer->objects[j];
CATCH(errctx, get_json_string_value((json_t *)layerdatavalue, "name", &tmpstr));
strncpy((char *)curobj->name, tmpstr->data, ACTOR_MAX_NAME_LENGTH);
CATCH(errctx, heap_release_string(tmpstr));
CATCH(errctx, get_json_number_value((json_t *)layerdatavalue, "x", &curobj->x));
CATCH(errctx, get_json_number_value((json_t *)layerdatavalue, "y", &curobj->y));
CATCH(errctx, get_json_boolean_value((json_t *)layerdatavalue, "visible", &curobj->visible));
CATCH(errctx, akgl_get_json_string_value((json_t *)layerdatavalue, "name", &tmpstr));
strncpy((char *)curobj->name, tmpstr->data, AKGL_ACTOR_MAX_NAME_LENGTH);
CATCH(errctx, akgl_heap_release_string(tmpstr));
CATCH(errctx, akgl_get_json_number_value((json_t *)layerdatavalue, "x", &curobj->x));
CATCH(errctx, akgl_get_json_number_value((json_t *)layerdatavalue, "y", &curobj->y));
CATCH(errctx, akgl_get_json_boolean_value((json_t *)layerdatavalue, "visible", &curobj->visible));
CATCH(errctx, get_json_string_value((json_t *)layerdatavalue, "type", &tmpstr));
CATCH(errctx, akgl_get_json_string_value((json_t *)layerdatavalue, "type", &tmpstr));
if ( strcmp(tmpstr->data, "actor") == 0 ) {
CATCH(errctx, tilemap_load_layer_object_actor(curobj, layerdatavalue, layerid));
CATCH(errctx, akgl_tilemap_load_layer_object_actor(curobj, layerdatavalue, layerid));
}
layerdatavalue = NULL;
}
@@ -287,7 +287,7 @@ akerr_ErrorContext *tilemap_load_layer_objects(tilemap *dest, json_t *root, int
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load_layer_tile(tilemap *dest, json_t *root, int layerid)
akerr_ErrorContext *akgl_tilemap_load_layer_tile(akgl_Tilemap *dest, json_t *root, int layerid)
{
PREPARE_ERROR(errctx);
json_t *layerdata = NULL;
@@ -298,15 +298,15 @@ akerr_ErrorContext *tilemap_load_layer_tile(tilemap *dest, json_t *root, int lay
FAIL_ZERO_RETURN(errctx, root, AKERR_NULLPOINTER, "NULL tilemap root reference");
ATTEMPT {
CATCH(errctx, get_json_integer_value(root, "height", &dest->layers[layerid].height));
CATCH(errctx, get_json_integer_value(root, "width", &dest->layers[layerid].width));
CATCH(errctx, get_json_array_value(root, "data", &layerdata));
CATCH(errctx, akgl_get_json_integer_value(root, "height", &dest->layers[layerid].height));
CATCH(errctx, akgl_get_json_integer_value(root, "width", &dest->layers[layerid].width));
CATCH(errctx, akgl_get_json_array_value(root, "data", &layerdata));
layerdatalen = (dest->layers[layerid].width * dest->layers[layerid].height);
if ( layerdatalen >= (TILEMAP_MAX_WIDTH * TILEMAP_MAX_HEIGHT) ) {
if ( layerdatalen >= (AKGL_TILEMAP_MAX_WIDTH * AKGL_TILEMAP_MAX_HEIGHT) ) {
FAIL_BREAK(errctx, AKERR_OUTOFBOUNDS, "Map layer exceeds the maximum size");
}
for ( j = 0; j < layerdatalen; j++ ) {
CATCH(errctx, get_json_array_index_integer(layerdata, j, &dest->layers[layerid].data[j]));
CATCH(errctx, akgl_get_json_array_index_integer(layerdata, j, &dest->layers[layerid].data[j]));
}
} CLEANUP {
} PROCESS(errctx) {
@@ -315,45 +315,45 @@ akerr_ErrorContext *tilemap_load_layer_tile(tilemap *dest, json_t *root, int lay
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load_layers(tilemap *dest, json_t *root)
akerr_ErrorContext *akgl_tilemap_load_layers(akgl_Tilemap *dest, json_t *root)
{
PREPARE_ERROR(errctx);
FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "tilemap_load_layers received NULL tilemap pointer");
FAIL_ZERO_RETURN(errctx, root, AKERR_NULLPOINTER, "tilemap_load_layers received NULL json object pointer");
FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "akgl_tilemap_load_layers received NULL tilemap pointer");
FAIL_ZERO_RETURN(errctx, root, AKERR_NULLPOINTER, "akgl_tilemap_load_layers received NULL json object pointer");
json_t *layers = NULL;
json_t *layer = NULL;
string *tmpstr = NULL;
akgl_String *tmpstr = NULL;
int i;
int tmpint;
ATTEMPT {
CATCH(errctx, get_json_array_value(root, "layers", &layers));
CATCH(errctx, akgl_get_json_array_value(root, "layers", &layers));
dest->numlayers = json_array_size((json_t *)layers);
for ( i = 0; i < dest->numlayers; i++) {
if ( i >= TILEMAP_MAX_LAYERS ) {
if ( i >= AKGL_TILEMAP_MAX_LAYERS ) {
FAIL_BREAK(errctx, AKERR_OUTOFBOUNDS, "Map exceeds the maximum number of layers");
}
CATCH(errctx, get_json_array_index_object((json_t *)layers, i, &layer));
CATCH(errctx, get_json_integer_value((json_t *)layer, "id", &tmpint));
CATCH(errctx, akgl_get_json_array_index_object((json_t *)layers, i, &layer));
CATCH(errctx, akgl_get_json_integer_value((json_t *)layer, "id", &tmpint));
if ( (tmpint - 1) != i ) {
// TileD's map layer IDs start at 1, not 0, and are sequential but not necessarily contiguous. We may have a gap in IDs.
layer = NULL;
continue;
}
CATCH(errctx, get_json_number_value((json_t *)layer, "opacity", &dest->layers[i].opacity));
CATCH(errctx, get_json_boolean_value((json_t *)layer, "visible", &dest->layers[i].visible));
CATCH(errctx, get_json_integer_value((json_t *)layer, "id", &dest->layers[i].id));
CATCH(errctx, get_json_integer_value((json_t *)layer, "x", &dest->layers[i].x));
CATCH(errctx, get_json_integer_value((json_t *)layer, "y", &dest->layers[i].y));
CATCH(errctx, akgl_get_json_number_value((json_t *)layer, "opacity", &dest->layers[i].opacity));
CATCH(errctx, akgl_get_json_boolean_value((json_t *)layer, "visible", &dest->layers[i].visible));
CATCH(errctx, akgl_get_json_integer_value((json_t *)layer, "id", &dest->layers[i].id));
CATCH(errctx, akgl_get_json_integer_value((json_t *)layer, "x", &dest->layers[i].x));
CATCH(errctx, akgl_get_json_integer_value((json_t *)layer, "y", &dest->layers[i].y));
CATCH(errctx, get_json_string_value((json_t *)layer, "type", &tmpstr));
CATCH(errctx, akgl_get_json_string_value((json_t *)layer, "type", &tmpstr));
if ( strncmp((char *)tmpstr->data, "objectgroup", strlen((char *)tmpstr->data)) == 0 ) {
dest->layers[i].type = TILEMAP_LAYER_TYPE_OBJECTS;
CATCH(errctx, tilemap_load_layer_objects((tilemap *)dest, (json_t *)layer, i));
dest->layers[i].type = AKGL_TILEMAP_LAYER_TYPE_OBJECTS;
CATCH(errctx, akgl_tilemap_load_layer_objects((akgl_Tilemap *)dest, (json_t *)layer, i));
} else if ( strncmp((char *)tmpstr->data, "tilelayer", strlen((char *)tmpstr->data)) == 0 ) {
dest->layers[i].type = TILEMAP_LAYER_TYPE_TILES;
CATCH(errctx, tilemap_load_layer_tile((tilemap *)dest, (json_t *)layer, i));
dest->layers[i].type = AKGL_TILEMAP_LAYER_TYPE_TILES;
CATCH(errctx, akgl_tilemap_load_layer_tile((akgl_Tilemap *)dest, (json_t *)layer, i));
}
layer = NULL;
}
@@ -363,23 +363,23 @@ akerr_ErrorContext *tilemap_load_layers(tilemap *dest, json_t *root)
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_load(char *fname, tilemap *dest)
akerr_ErrorContext *akgl_tilemap_load(char *fname, akgl_Tilemap *dest)
{
PREPARE_ERROR(errctx);
json_t *json = NULL;
//string *tmpstr = NULL;
//akgl_String *tmpstr = NULL;
json_error_t error;
FAIL_ZERO_RETURN(errctx, fname, AKERR_NULLPOINTER, "load_tilemap received null filename");
FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "load_tilemap received null tilemap");
memset(dest, 0x00, sizeof(tilemap));
memset(dest, 0x00, sizeof(akgl_Tilemap));
ATTEMPT {
//CATCH(errctx, heap_next_string(&tmpstr));
//CATCH(errctx, string_initialize(tmpstr, NULL));
//SDL_snprintf(tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), fname);
//CATCH(errctx, akgl_heap_next_string(&tmpstr));
//CATCH(errctx, akgl_string_initialize(tmpstr, NULL));
//SDL_snprintf(tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), fname);
json = json_load_file(fname, 0, &error);
FAIL_ZERO_BREAK(
errctx,
@@ -390,26 +390,26 @@ akerr_ErrorContext *tilemap_load(char *fname, tilemap *dest)
error.line,
error.text
);
CATCH(errctx, get_json_integer_value((json_t *)json, "tileheight", &dest->tileheight));
CATCH(errctx, get_json_integer_value((json_t *)json, "tilewidth", &dest->tilewidth));
CATCH(errctx, get_json_integer_value((json_t *)json, "height", &dest->height));
CATCH(errctx, get_json_integer_value((json_t *)json, "width", &dest->width));
CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "tileheight", &dest->tileheight));
CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "tilewidth", &dest->tilewidth));
CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "height", &dest->height));
CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "width", &dest->width));
dest->orientation = 0;
if ( (dest->width * dest->height) >= (TILEMAP_MAX_WIDTH * TILEMAP_MAX_HEIGHT) ) {
if ( (dest->width * dest->height) >= (AKGL_TILEMAP_MAX_WIDTH * AKGL_TILEMAP_MAX_HEIGHT) ) {
FAIL_RETURN(errctx, AKERR_OUTOFBOUNDS, "Map exceeds the maximum size");
}
CATCH(errctx, tilemap_load_layers((tilemap *)dest, (json_t *)json));
CATCH(errctx, tilemap_load_tilesets((tilemap *)dest, (json_t *)json));
CATCH(errctx, akgl_tilemap_load_layers((akgl_Tilemap *)dest, (json_t *)json));
CATCH(errctx, akgl_tilemap_load_tilesets((akgl_Tilemap *)dest, (json_t *)json));
} CLEANUP {
//IGNORE(heap_release_string(tmpstr));
//IGNORE(akgl_heap_release_string(tmpstr));
} PROCESS(errctx) {
} FINISH(errctx, true);
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_draw(SDL_Renderer *renderer, tilemap *map, SDL_FRect *viewport, int layeridx)
akerr_ErrorContext *akgl_tilemap_draw(SDL_Renderer *renderer, akgl_Tilemap *map, SDL_FRect *viewport, int layeridx)
{
PREPARE_ERROR(errctx);
SDL_FRect dest = {.x = 0, .y = 0, .w = 0, .h = 0};;
@@ -439,8 +439,8 @@ akerr_ErrorContext *tilemap_draw(SDL_Renderer *renderer, tilemap *map, SDL_FRect
* 0 and 8 would not be rendered. 1, 9, 6, and E would be partially rendered at their corner.
* 2,3,4,5 and A,B,C,D would be partially rendered with a slice from their center.
*/
FAIL_ZERO_RETURN(errctx, map, AKERR_NULLPOINTER, "tilemap_draw received NULL pointer to tilemap");
FAIL_ZERO_RETURN(errctx, viewport, AKERR_NULLPOINTER, "tilemap_draw received NULL pointer to viewport");
FAIL_ZERO_RETURN(errctx, map, AKERR_NULLPOINTER, "akgl_tilemap_draw received NULL pointer to tilemap");
FAIL_ZERO_RETURN(errctx, viewport, AKERR_NULLPOINTER, "akgl_tilemap_draw received NULL pointer to viewport");
/* Only try to render the stuff that is partially within the viewport */
@@ -519,7 +519,7 @@ akerr_ErrorContext *tilemap_draw(SDL_Renderer *renderer, tilemap *map, SDL_FRect
SUCCEED_RETURN(errctx);
}
akerr_ErrorContext *tilemap_draw_tileset(SDL_Renderer *renderer, tilemap *map, int tilesetidx)
akerr_ErrorContext *akgl_tilemap_draw_tileset(SDL_Renderer *renderer, akgl_Tilemap *map, int tilesetidx)
{
PREPARE_ERROR(errctx);
SDL_FRect dest;
@@ -531,8 +531,8 @@ akerr_ErrorContext *tilemap_draw_tileset(SDL_Renderer *renderer, tilemap *map, i
* by proving that we can reconstruct the original tileset image)
*/
FAIL_ZERO_RETURN(errctx, map, AKERR_NULLPOINTER, "tilemap_draw_tileset received NULL pointer to tilemap");
FAIL_NONZERO_RETURN(errctx, (tilesetidx >= map->numtilesets), AKERR_OUTOFBOUNDS, "tilemap_draw_tileset received a tileset index out of bounds");
FAIL_ZERO_RETURN(errctx, map, AKERR_NULLPOINTER, "akgl_tilemap_draw_tileset received NULL pointer to tilemap");
FAIL_NONZERO_RETURN(errctx, (tilesetidx >= map->numtilesets), AKERR_OUTOFBOUNDS, "akgl_tilemap_draw_tileset received a tileset index out of bounds");
for ( tilenum = 0; tilenum < map->tilesets[tilesetidx].tilecount; tilenum++) {
// Render this tile to the correct screen position