Add types.h, standardize integer types on stdint

CMakeLists.txt

@@ -101,6 +101,7 @@ set(main_lib_dest "lib/akgl-${MY_LIBRARY_VERSION}")
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/akgl.pc DESTINATION "lib/pkgconfig/")
 install(TARGETS akgl DESTINATION "lib/")
 install(FILES "include/akgl/actor.h" DESTINATION "include/akgl/")
+install(FILES "include/akgl/types.h" DESTINATION "include/akgl/")
 install(FILES "include/akgl/text.h" DESTINATION "include/akgl/")
 install(FILES "include/akgl/assets.h" DESTINATION "include/akgl/")
 install(FILES "include/akgl/character.h" DESTINATION "include/akgl/")

include/akgl/SDL_GameControllerDB.h

@@ -1,7 +1,7 @@
 #ifndef _SDL_GAMECONTROLLERDB_H_
 #define _SDL_GAMECONTROLLERDB_H_
 
-// Taken from https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/refs/heads/master/gamecontrollerdb.txt on Fri May  8 10:15:43 AM EDT 2026
+// Taken from https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/refs/heads/master/gamecontrollerdb.txt on Fri May  8 10:01:12 PM EDT 2026
 
 #define AKGL_SDL_GAMECONTROLLER_DB_LEN         2227
 

include/akgl/actor.h

@@ -1,6 +1,8 @@
 #ifndef _AKGL_ACTOR_H_
 #define _AKGL_ACTOR_H_
 
+#include <stdint.h>
+#include "types.h"
 #include "character.h"
 
 //           ---- LOW WORD STATUSES ----
@@ -57,20 +59,20 @@ extern char *AKGL_ACTOR_STATE_STRING_NAMES[AKGL_ACTOR_MAX_STATES+1];
 #define AKGL_MAX_HEAP_ACTOR                    64
 
 typedef struct akgl_Actor {
-  int refcount;
+  uint8_t refcount;
   char name[AKGL_ACTOR_MAX_NAME_LENGTH];
   akgl_Character *basechar;
-  int curSpriteFrameId;
+  uint8_t curSpriteFrameId;
   SDL_Time curSpriteFrameTimer;
   bool curSpriteReversing;
-  int layer;
+  uint32_t layer;
-  int state;
+  int32_t state;
   bool movement_controls_face;
   void *actorData;
   bool visible;
   SDL_Time logictimer;
-  float x;
+  float32_t x;
-  float y;
+  float32_t y;
   struct akgl_Actor *children[AKGL_ACTOR_MAX_CHILDREN];
   struct akgl_Actor *parent;
   akerr_ErrorContext AKERR_NOIGNORE *(*updatefunc)(struct akgl_Actor *obj);

include/akgl/character.h

@@ -2,20 +2,21 @@
 #define _AKGL_CHARACTER_H_
 
 #include <SDL3/SDL_properties.h>
+#include "types.h"
 #include "sprite.h"
 
 #define AKGL_SPRITE_MAX_CHARACTER_NAME_LENGTH  128
 #define AKGL_MAX_HEAP_CHARACTER                256
 
 typedef struct akgl_Character {
-  int refcount;
+  uint8_t refcount;
   char name[AKGL_SPRITE_MAX_CHARACTER_NAME_LENGTH];
   SDL_PropertiesID state_sprites;
   akerr_ErrorContext AKERR_NOIGNORE *(*sprite_add)(struct akgl_Character *, akgl_Sprite *, int);
   akerr_ErrorContext AKERR_NOIGNORE *(*sprite_get)(struct akgl_Character *, int, akgl_Sprite **);
-  long int movementspeed;
+  uint64_t movementspeed;
-  float vx;
+  float32_t vx;
-  float vy;
+  float32_t vy;
 } akgl_Character;
 
 

include/akgl/controller.h

@@ -3,25 +3,26 @@
 
 #include <SDL3/SDL.h>
 #include <akerror.h>
+#include "types.h"
 
 #define AKGL_MAX_CONTROL_MAPS 8
 #define AKGL_MAX_CONTROLS     32
 
 typedef struct {
-    Uint32 event_on;
+    uint32_t event_on;
-    Uint32 event_off;
+    uint32_t event_off;
-    Uint8 button;
+    uint8_t button;
     SDL_Keycode key;
-    Uint8 axis;
+    uint8_t axis;
-    Uint8 axis_range_min;
+    uint8_t axis_range_min;
-    Uint8 axis_range_max;
+    uint8_t axis_range_max;
     akerr_ErrorContext AKERR_NOIGNORE *(*handler_on)(akgl_Actor *obj, SDL_Event *event);
     akerr_ErrorContext AKERR_NOIGNORE *(*handler_off)(akgl_Actor *obj, SDL_Event *event);
 } akgl_Control;
 
 typedef struct {
     akgl_Actor *target;
-    int nextMap;
+    uint16_t nextMap;
     akgl_Control controls[AKGL_MAX_CONTROLS];
     SDL_KeyboardID kbid;
     SDL_JoystickID jsid;

include/akgl/game.h

@@ -1,6 +1,8 @@
 #ifndef _AKGL_GAME_H_
 #define _AKGL_GAME_H_
 
+#include <stdint.h>
+#include "types.h"
 #include <SDL3_mixer/SDL_mixer.h>
 #include "tilemap.h"
 
@@ -13,32 +15,31 @@
 /* ==================== GAME STATE VARIABLES =================== */
 
 typedef struct {
-  float w;
+    float32_t w;
-  float h;
+    float32_t h;
-  SDL_Texture *texture;
+    SDL_Texture *texture;
 } akgl_Frame;
 
 typedef struct {
-  int flags;
+    int32_t flags;
 } akgl_GameState;
 
 typedef struct {
     char name[256];
     char version[32];
     char uri[256];
-    int screenwidth;
+    int16_t screenwidth;
-    int screenheight;
+    int16_t screenheight;
     akgl_GameState state;
-    int fps;
+    int16_t fps;
     SDL_Time gameStartTime;
     SDL_Time lastIterTime;
     SDL_Time lastFPSTime;
-    int framesSinceUpdate;
+    int16_t framesSinceUpdate;
     MIX_Mixer *mixer;
     MIX_Track *tracks[AKGL_GAME_AUDIO_MAX_TRACKS];
 } akgl_Game;
 
-
 extern SDL_Window *window;
 extern SDL_Renderer *renderer;
 extern akgl_Tilemap gamemap;
@@ -53,5 +54,7 @@ extern akgl_Game game;
 
 akerr_ErrorContext AKERR_NOIGNORE *akgl_game_init();
 void akgl_game_updateFPS();
+akerr_ErrorContext AKERR_NOIGNORE *akgl_game_save(char *fpath);
+akerr_ErrorContext AKERR_NOIGNORE *akgl_game_load(char *fpath);
 
 #endif //_AKGL_GAME_H_

include/akgl/iterator.h

@@ -2,8 +2,8 @@
 #define _AKGL_ITERATOR_H_
 
 typedef struct {
-  int flags;
+    uint32_t flags;
-  int layerid;
+    uint8_t layerid;
 } akgl_Iterator;
 
 #define AKGL_ITERATOR_OP_UPDATE                1                    // 1

include/akgl/registry.h

@@ -20,6 +20,7 @@ akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_sprite();
 akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_spritesheet();
 akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_character();
 akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_properties();
+akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_load_properties(char *fname);
 akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_actor_state_strings();
 
 

include/akgl/sprite.h

@@ -15,24 +15,24 @@
 #define AKGL_MAX_HEAP_SPRITESHEET              AKGL_MAX_HEAP_SPRITE
 
 typedef struct {
-  int refcount;
+    uint8_t refcount;
-  SDL_Texture *texture;
+    SDL_Texture *texture;
-  char name[AKGL_SPRITE_SHEET_MAX_FILENAME_LENGTH];
+    char name[AKGL_SPRITE_SHEET_MAX_FILENAME_LENGTH];
-  int sprite_w;
+    uint16_t sprite_w;
-  int sprite_h;
+    uint16_t sprite_h;
 } akgl_SpriteSheet;
 
 typedef struct {
-  int refcount;
+    uint8_t refcount;
-  akgl_SpriteSheet *sheet;
+    akgl_SpriteSheet *sheet;
-  int frameids[AKGL_SPRITE_MAX_FRAMES]; // which IDs on the spritesheet belong to our frames
+    uint8_t frameids[AKGL_SPRITE_MAX_FRAMES]; // which IDs on the spritesheet belong to our frames
-  int frames; // how many frames are in this animation
+    uint32_t frames; // how many frames are in this animation
-  int width;
+    uint32_t width;
-  int height;
+    uint32_t height;
-  long int speed; // how many milliseconds a given sprite frame should be visible before cycling
+    uint32_t speed; // how many milliseconds a given sprite frame should be visible before cycling
-  bool loop; // when this sprite is done playing, it should immediately start again
+    bool loop; // when this sprite is done playing, it should immediately start again
-  bool loopReverse; // when this sprite is done playing, it should go in reverse order through its frames
+    bool loopReverse; // when this sprite is done playing, it should go in reverse order through its frames
-  char name[AKGL_SPRITE_MAX_NAME_LENGTH];
+    char name[AKGL_SPRITE_MAX_NAME_LENGTH];
 } akgl_Sprite;
 
 // initializes a new sprite to use the given sheet and otherwise sets to zero

include/akgl/types.h

@@ -0,0 +1,9 @@
+#ifndef _AKGL_TYPES_H_
+#define _AKGL_TYPES_H_
+
+#include <stdint.h>
+
+typedef float float32_t;
+typedef double float64_t;
+
+#endif // _AKGL_TYPES_H_

src/game.c

@@ -104,7 +104,8 @@ akerr_ErrorContext AKERR_NOIGNORE *akgl_game_init()
     camera.x = 0;
     camera.y = 0;
     camera.w = game.screenwidth;
-    camera.h = game.screenheight;    
+    camera.h = game.screenheight;
+    SUCCEED(errctx);
 }
 
 void akgl_game_updateFPS()
@@ -119,3 +120,20 @@ void akgl_game_updateFPS()
     game.framesSinceUpdate += 1;
     game.lastIterTime = curTime;
 }
+
+akerr_ErrorContext AKERR_NOIGNORE *akgl_game_save(char *fpath)
+{
+    FILE *fp = NULL;
+    PREPARE_ERROR(errctx);
+
+    FAIL_ZERO_RETURN(errctx, fpath, AKERR_NULLPOINTER, "NULL file path");
+    fp = fopen(fpath, "rb");
+    fclose(fp);
+    SUCCEED(errctx); // SUCCEED_NORETURN if in main().
+}
+
+akerr_ErrorContext AKERR_NOIGNORE *akgl_game_load(char *fpath)
+{
+    PREPARE_ERROR(errctx);
+    SUCCEED(errctx);
+}

src/registry.c

@@ -1,10 +1,13 @@
 #include <SDL3/SDL.h>
 #include <akerror.h>
+#include <jansson.h>
 
+#include <akgl/heap.h>
 #include <akgl/sprite.h>
 #include <akgl/registry.h>
 #include <akgl/iterator.h>
 #include <akgl/actor.h>
+#include <akgl/json_helpers.h>
 
 SDL_PropertiesID AKGL_REGISTRY_ACTOR;
 SDL_PropertiesID AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS;
@@ -104,3 +107,45 @@ akerr_ErrorContext *akgl_registry_init_character()
     FAIL_ZERO_RETURN(errctx, AKGL_REGISTRY_CHARACTER, AKERR_NULLPOINTER, "Error initializing character registry");
     SUCCEED_RETURN(errctx);
 }
+
+akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_load_properties(char *fname)
+{
+    json_t *json = NULL;
+    json_t *props = NULL;
+    const char *pkey = NULL;
+    json_t *pvalue = NULL;
+    
+    json_error_t error;
+    akgl_String *tmpstr;
+
+    PREPARE_ERROR(errctx);
+    FAIL_ZERO_RETURN(errctx, fname, AKERR_NULLPOINTER, "null filename");
+    ATTEMPT {
+	SDL_Log("Loading from %s", fname);
+	json = json_load_file(fname, 0, &error);
+	FAIL_ZERO_BREAK(
+	    errctx,
+	    json,
+	    AKERR_NULLPOINTER,
+	    "Error while loading properties from %s on line %d: %s-",
+	    fname,
+	    error.line,
+	    error.text);
+	CATCH(errctx, akgl_get_json_object_value(json, "properties", &props));
+    } CLEANUP {
+    } PROCESS(errctx) {
+    } FINISH(errctx, true);
+
+    json_object_foreach(props, pkey, pvalue) {
+	ATTEMPT {
+	    CATCH(errctx, akgl_heap_next_string(&tmpstr));
+	    CATCH(errctx, akgl_get_json_string_value(props, (char *)pkey, &tmpstr));
+	    SDL_SetStringProperty(AKGL_REGISTRY_PROPERTIES, pkey, tmpstr->data);
+	    CATCH(errctx, akgl_heap_release_string(tmpstr));
+	} CLEANUP {
+	} PROCESS(errctx) {
+	} FINISH(errctx, true);
+    }
+    SDL_Log("Properties loaded");
+    SUCCEED(errctx);
+}

src/sprite.c

@@ -98,7 +98,7 @@ akerr_ErrorContext *akgl_sprite_load_json(char *filename)
        
 	CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "width", &obj->width));
 	CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "height", &obj->height));
-	CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "speed", (int *)&obj->speed));
+	CATCH(errctx, akgl_get_json_integer_value((json_t *)json, "speed", &obj->speed));
 	obj->speed = obj->speed * AKGL_TIME_ONESEC_MS;
 	CATCH(errctx, akgl_get_json_boolean_value((json_t *)json, "loop", &obj->loop));
 	CATCH(errctx, akgl_get_json_boolean_value((json_t *)json, "loopReverse", &obj->loopReverse));
@@ -106,7 +106,7 @@ akerr_ErrorContext *akgl_sprite_load_json(char *filename)
 	CATCH(errctx, akgl_get_json_array_value((json_t *)json, "frames", &frames));
 	obj->frames = json_array_size((json_t *)frames);
 	for ( i = 0 ; i < obj->frames; i++ ) {
-	    CATCH(errctx, akgl_get_json_array_index_integer((json_t *)frames, i, &obj->frameids[i]));
+	    CATCH(errctx, akgl_get_json_array_index_integer((json_t *)frames, i, (uint32_t *)&obj->frameids[i]));
 	}
     } CLEANUP {
 	if ( errctx != NULL && errctx->status != 0 ) {

tests/sprite.c

@@ -126,7 +126,7 @@ akerr_ErrorContext *test_akgl_sprite_load_json(void)
 
       FAIL_ZERO_BREAK(errctx, (testsprite->width == 48), AKERR_VALUE, "width incorrect (48 : %d)", testsprite->width);
       FAIL_ZERO_BREAK(errctx, (testsprite->height == 48), AKERR_VALUE, "height incorrect (48 : %d)", testsprite->height);
-      FAIL_ZERO_BREAK(errctx, (testsprite->speed == 100000000), AKERR_VALUE, "speed incorrect (100 : %ld)", testsprite->speed);
+      FAIL_ZERO_BREAK(errctx, (testsprite->speed == 100000000), AKERR_VALUE, "speed incorrect (100 : %d)", testsprite->speed);
       FAIL_ZERO_BREAK(errctx, (testsprite->loop == true), AKERR_VALUE, "loop incorrect (1 : %d)", testsprite->loop);
       FAIL_ZERO_BREAK(errctx, (testsprite->loopReverse == true), AKERR_VALUE, "loopReverse incorrect (1 : %d)", testsprite->loopReverse);
       FAIL_ZERO_BREAK(errctx, (testsprite->frames == 3), AKERR_VALUE, "frame count incorrect (3 : %d)", testsprite->frames);