diff --git a/include/controller.h b/include/controller.h deleted file mode 100644 index 408eb64..0000000 --- a/include/controller.h +++ /dev/null @@ -1,12 +0,0 @@ -#ifndef _GAMEPAD_H_ -#define _GAMEPAD_H_ - -#include -#include - -ErrorContext ERROR_NOIGNORE *gamepad_handle_button_down(void *appstate, SDL_Event *event); -ErrorContext ERROR_NOIGNORE *gamepad_handle_button_up(void *appstate, SDL_Event *event); -ErrorContext ERROR_NOIGNORE *gamepad_handle_added(void *appstate, SDL_Event *event); -ErrorContext ERROR_NOIGNORE *gamepad_handle_removed(void *appstate, SDL_Event *event); - -#endif // _GAMEPAD_H_ diff --git a/include/sdl3game/SDL_GameControllerDB.h b/include/sdl3game/SDL_GameControllerDB.h index 390be1d..7b511a2 100644 --- a/include/sdl3game/SDL_GameControllerDB.h +++ b/include/sdl3game/SDL_GameControllerDB.h @@ -1,9 +1,9 @@ #ifndef _SDL_GAMECONTROLLERDB_H_ #define _SDL_GAMECONTROLLERDB_H_ -// Taken from https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/refs/heads/master/gamecontrollerdb.txt on Wed May 6 11:52:34 AM EDT 2026 +// Taken from https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/refs/heads/master/gamecontrollerdb.txt on Thu May 7 10:00:08 PM EDT 2026 -#define SDL_GAMECONTROLLER_DB_LEN 2225 +#define AKGL_SDL_GAMECONTROLLER_DB_LEN 2225 const char *SDL_GAMECONTROLLER_DB[] = { "03000000300f00000a01000000000000,3 In 1 Conversion Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b8,x:b3,y:b0,platform:Windows", diff --git a/include/sdl3game/actor.h b/include/sdl3game/actor.h index 5bdaa9d..65d8bd6 100644 --- a/include/sdl3game/actor.h +++ b/include/sdl3game/actor.h @@ -1,65 +1,65 @@ -#ifndef _ACTOR_H_ -#define _ACTOR_H_ +#ifndef _AKGL_ACTOR_H_ +#define _AKGL_ACTOR_H_ #include "character.h" // ---- LOW WORD STATUSES ---- -#define ACTOR_STATE_FACE_DOWN 1 << 0 // 1 0000 0000 0000 0001 -#define ACTOR_STATE_FACE_LEFT 1 << 1 // 2 0000 0000 0000 0010 -#define ACTOR_STATE_FACE_RIGHT 1 << 2 // 4 0000 0000 0000 0100 -#define ACTOR_STATE_FACE_UP 1 << 3 // 8 0000 0000 0000 1000 -#define ACTOR_STATE_ALIVE 1 << 4 // 16 0000 0000 0001 0000 -#define ACTOR_STATE_DYING 1 << 5 // 32 0000 0000 0010 0000 -#define ACTOR_STATE_DEAD 1 << 6 // 64 0000 0000 0100 0000 -#define ACTOR_STATE_MOVING_LEFT 1 << 7 // 128 0000 0000 1000 0000 -#define ACTOR_STATE_MOVING_RIGHT 1 << 8 // 256 0000 0001 0000 0000 -#define ACTOR_STATE_MOVING_UP 1 << 9 // 512 0000 0010 0000 0000 -#define ACTOR_STATE_MOVING_DOWN 1 << 10 // 1024 0000 0100 0000 0000 -#define ACTOR_STATE_UNDEFINED_11 1 << 11 // 2048 0000 1000 0000 0000 -#define ACTOR_STATE_UNDEFINED_12 1 << 12 // 4096 0001 0000 0000 0000 -#define ACTOR_STATE_UNDEFINED_13 1 << 13 // 8192 0010 0000 0000 0000 -#define ACTOR_STATE_UNDEFINED_14 1 << 14 // 16384 0100 0000 0000 0000 -#define ACTOR_STATE_UNDEFINED_15 1 << 15 // 32768 1000 0000 0000 0000 +#define AKGL_ACTOR_STATE_FACE_DOWN 1 << 0 // 1 0000 0000 0000 0001 +#define AKGL_ACTOR_STATE_FACE_LEFT 1 << 1 // 2 0000 0000 0000 0010 +#define AKGL_ACTOR_STATE_FACE_RIGHT 1 << 2 // 4 0000 0000 0000 0100 +#define AKGL_ACTOR_STATE_FACE_UP 1 << 3 // 8 0000 0000 0000 1000 +#define AKGL_ACTOR_STATE_ALIVE 1 << 4 // 16 0000 0000 0001 0000 +#define AKGL_ACTOR_STATE_DYING 1 << 5 // 32 0000 0000 0010 0000 +#define AKGL_ACTOR_STATE_DEAD 1 << 6 // 64 0000 0000 0100 0000 +#define AKGL_ACTOR_STATE_MOVING_LEFT 1 << 7 // 128 0000 0000 1000 0000 +#define AKGL_ACTOR_STATE_MOVING_RIGHT 1 << 8 // 256 0000 0001 0000 0000 +#define AKGL_ACTOR_STATE_MOVING_UP 1 << 9 // 512 0000 0010 0000 0000 +#define AKGL_ACTOR_STATE_MOVING_DOWN 1 << 10 // 1024 0000 0100 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_11 1 << 11 // 2048 0000 1000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_12 1 << 12 // 4096 0001 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_13 1 << 13 // 8192 0010 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_14 1 << 14 // 16384 0100 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_15 1 << 15 // 32768 1000 0000 0000 0000 // ----- HIGH WORD STATUSES ----- -#define ACTOR_STATE_UNDEFINED_16 1 << 16 // 65536 0000 0000 0000 0001 -#define ACTOR_STATE_UNDEFINED_17 1 << 17 // 131072 0000 0000 0000 0010 -#define ACTOR_STATE_UNDEFINED_18 1 << 18 // 262144 0000 0000 0000 0100 -#define ACTOR_STATE_UNDEFINED_19 1 << 19 // 524288 0000 0000 0000 1000 -#define ACTOR_STATE_UNDEFINED_20 1 << 20 // 1048576 0000 0000 0001 0000 -#define ACTOR_STATE_UNDEFINED_21 1 << 21 // 2097152 0000 0000 0010 0000 -#define ACTOR_STATE_UNDEFINED_22 1 << 22 // 4194304 0000 0000 0100 0000 -#define ACTOR_STATE_UNDEFINED_23 1 << 23 // 8388608 0000 0000 1000 0000 -#define ACTOR_STATE_UNDEFINED_24 1 << 24 // 16777216 0000 0001 0000 0000 -#define ACTOR_STATE_UNDEFINED_25 1 << 25 // 33554432 0000 0010 0000 0000 -#define ACTOR_STATE_UNDEFINED_26 1 << 26 // 67108864 0000 0100 0000 0000 -#define ACTOR_STATE_UNDEFINED_27 1 << 27 // 134217728 0000 1000 0000 0000 -#define ACTOR_STATE_UNDEFINED_28 1 << 28 // 268435456 0001 0000 0000 0000 -#define ACTOR_STATE_UNDEFINED_29 1 << 29 // 536870912 0010 0000 0000 0000 -#define ACTOR_STATE_UNDEFINED_30 1 << 30 // 1073741824 0100 0000 0000 0000 -#define ACTOR_STATE_UNDEFINED_31 1 << 31 // 2147483648 1000 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_16 1 << 16 // 65536 0000 0000 0000 0001 +#define AKGL_ACTOR_STATE_UNDEFINED_17 1 << 17 // 131072 0000 0000 0000 0010 +#define AKGL_ACTOR_STATE_UNDEFINED_18 1 << 18 // 262144 0000 0000 0000 0100 +#define AKGL_ACTOR_STATE_UNDEFINED_19 1 << 19 // 524288 0000 0000 0000 1000 +#define AKGL_ACTOR_STATE_UNDEFINED_20 1 << 20 // 1048576 0000 0000 0001 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_21 1 << 21 // 2097152 0000 0000 0010 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_22 1 << 22 // 4194304 0000 0000 0100 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_23 1 << 23 // 8388608 0000 0000 1000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_24 1 << 24 // 16777216 0000 0001 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_25 1 << 25 // 33554432 0000 0010 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_26 1 << 26 // 67108864 0000 0100 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_27 1 << 27 // 134217728 0000 1000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_28 1 << 28 // 268435456 0001 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_29 1 << 29 // 536870912 0010 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_30 1 << 30 // 1073741824 0100 0000 0000 0000 +#define AKGL_ACTOR_STATE_UNDEFINED_31 1 << 31 // 2147483648 1000 0000 0000 0000 -#define ACTOR_MAX_STATES 32 +#define AKGL_ACTOR_MAX_STATES 32 // This is an array of strings equal to actor states from 1-32. // This is built by a utility script and not kept in git, see // the Makefile for lib_src/actor_state_string_names.c -extern char *ACTOR_STATE_STRING_NAMES[ACTOR_MAX_STATES+1]; +extern char *AKGL_ACTOR_STATE_STRING_NAMES[AKGL_ACTOR_MAX_STATES+1]; -#define ACTOR_STATE_FACE_ALL (ACTOR_STATE_FACE_DOWN | ACTOR_STATE_FACE_LEFT | ACTOR_STATE_FACE_RIGHT | ACTOR_STATE_FACE_UP) -#define ACTOR_STATE_MOVING_ALL (ACTOR_STATE_MOVING_LEFT | ACTOR_STATE_MOVING_RIGHT | ACTOR_STATE_MOVING_UP | ACTOR_STATE_MOVING_DOWN) +#define AKGL_ACTOR_STATE_FACE_ALL (AKGL_ACTOR_STATE_FACE_DOWN | AKGL_ACTOR_STATE_FACE_LEFT | AKGL_ACTOR_STATE_FACE_RIGHT | AKGL_ACTOR_STATE_FACE_UP) +#define AKGL_ACTOR_STATE_MOVING_ALL (AKGL_ACTOR_STATE_MOVING_LEFT | AKGL_ACTOR_STATE_MOVING_RIGHT | AKGL_ACTOR_STATE_MOVING_UP | AKGL_ACTOR_STATE_MOVING_DOWN) -#define ACTOR_MAX_NAME_LENGTH 128 -#define ACTOR_MAX_CHILDREN 8 +#define AKGL_ACTOR_MAX_NAME_LENGTH 128 +#define AKGL_ACTOR_MAX_CHILDREN 8 -#define MAX_HEAP_ACTOR 64 +#define AKGL_MAX_HEAP_ACTOR 64 -typedef struct actor { +typedef struct akgl_Actor { int refcount; - char name[ACTOR_MAX_NAME_LENGTH]; - character *basechar; + char name[AKGL_ACTOR_MAX_NAME_LENGTH]; + akgl_Character *basechar; int curSpriteFrameId; SDL_Time curSpriteFrameTimer; bool curSpriteReversing; @@ -71,35 +71,34 @@ typedef struct actor { SDL_Time logictimer; float x; float y; - struct actor *children[ACTOR_MAX_CHILDREN]; - struct actor *parent; - akerr_ErrorContext AKERR_NOIGNORE *(*updatefunc)(struct actor *obj); - akerr_ErrorContext AKERR_NOIGNORE *(*renderfunc)(struct actor *obj, SDL_Renderer *renderer); - akerr_ErrorContext AKERR_NOIGNORE *(*facefunc)(struct actor *obj); - akerr_ErrorContext AKERR_NOIGNORE *(*movementlogicfunc)(struct actor *obj, SDL_Time curtimems); - akerr_ErrorContext AKERR_NOIGNORE *(*changeframefunc)(struct actor *obj, sprite *curSprite, SDL_Time curtimems); - akerr_ErrorContext AKERR_NOIGNORE *(*addchild)(struct actor *obj, struct actor *child); -} actor; + struct akgl_Actor *children[AKGL_ACTOR_MAX_CHILDREN]; + struct akgl_Actor *parent; + akerr_ErrorContext AKERR_NOIGNORE *(*updatefunc)(struct akgl_Actor *obj); + akerr_ErrorContext AKERR_NOIGNORE *(*renderfunc)(struct akgl_Actor *obj, SDL_Renderer *renderer); + akerr_ErrorContext AKERR_NOIGNORE *(*facefunc)(struct akgl_Actor *obj); + akerr_ErrorContext AKERR_NOIGNORE *(*movementlogicfunc)(struct akgl_Actor *obj, SDL_Time curtimems); + akerr_ErrorContext AKERR_NOIGNORE *(*changeframefunc)(struct akgl_Actor *obj, akgl_Sprite *curSprite, SDL_Time curtimems); + akerr_ErrorContext AKERR_NOIGNORE *(*addchild)(struct akgl_Actor *obj, struct akgl_Actor *child); +} akgl_Actor; -akerr_ErrorContext AKERR_NOIGNORE *actor_initialize(actor *obj, char *name); -akerr_ErrorContext AKERR_NOIGNORE *actor_set_character(actor *obj, char *basecharname); -akerr_ErrorContext AKERR_NOIGNORE *actor_render(actor *obj, SDL_Renderer *renderer); -akerr_ErrorContext AKERR_NOIGNORE *actor_update(actor *obj); -akerr_ErrorContext AKERR_NOIGNORE *actor_logic_movement(actor *obj, SDL_Time curtimems); -akerr_ErrorContext AKERR_NOIGNORE *actor_logic_changeframe(actor *obj, sprite *curSprite, SDL_Time curtimems); -akerr_ErrorContext AKERR_NOIGNORE *actor_automatic_face(actor *obj); -akerr_ErrorContext AKERR_NOIGNORE *actor_add_child(actor *obj, actor *child); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_initialize(akgl_Actor *obj, char *name); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_set_character(akgl_Actor *obj, char *basecharname); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_render(akgl_Actor *obj, SDL_Renderer *renderer); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_update(akgl_Actor *obj); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_logic_movement(akgl_Actor *obj, SDL_Time curtimems); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_logic_changeframe(akgl_Actor *obj, akgl_Sprite *curSprite, SDL_Time curtimems); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_automatic_face(akgl_Actor *obj); +akerr_ErrorContext AKERR_NOIGNORE *akgl_actor_add_child(akgl_Actor *obj, akgl_Actor *child); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_left_on(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_left_off(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_right_on(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_right_off(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_up_on(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_up_off(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_down_on(actor *obj, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_down_off(actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_left_on(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_left_off(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_right_on(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_right_off(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_up_on(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_up_off(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_down_on(akgl_Actor *obj, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_down_off(akgl_Actor *obj, SDL_Event *event); +void akgl_registry_iterate_actor(void *userdata, SDL_PropertiesID registry, const char *name); -void registry_iterate_actor(void *userdata, SDL_PropertiesID registry, const char *name); - -#endif // _ACTOR_H_ +#endif // _AKGL_ACTOR_H_ diff --git a/include/sdl3game/assets.h b/include/sdl3game/assets.h index d693cd3..0ce126e 100644 --- a/include/sdl3game/assets.h +++ b/include/sdl3game/assets.h @@ -3,6 +3,6 @@ #include -akerr_ErrorContext AKERR_NOIGNORE *load_start_bgm(char *fname); +akerr_ErrorContext AKERR_NOIGNORE *akgl_load_start_bgm(char *fname); #endif //_ASSETS_H_ diff --git a/include/sdl3game/character.h b/include/sdl3game/character.h index db1efe0..0450fdc 100644 --- a/include/sdl3game/character.h +++ b/include/sdl3game/character.h @@ -1,31 +1,31 @@ -#ifndef _CHARACTER_H_ -#define _CHARACTER_H_ +#ifndef _AKGL_CHARACTER_H_ +#define _AKGL_CHARACTER_H_ #include #include "sprite.h" -#define SPRITE_MAX_CHARACTER_NAME_LENGTH 128 -#define MAX_HEAP_CHARACTER 256 +#define AKGL_SPRITE_MAX_CHARACTER_NAME_LENGTH 128 +#define AKGL_MAX_HEAP_CHARACTER 256 -typedef struct character { +typedef struct akgl_Character { int refcount; - char name[SPRITE_MAX_CHARACTER_NAME_LENGTH]; + char name[AKGL_SPRITE_MAX_CHARACTER_NAME_LENGTH]; SDL_PropertiesID state_sprites; - akerr_ErrorContext AKERR_NOIGNORE *(*sprite_add)(struct character *, sprite *, int); - akerr_ErrorContext AKERR_NOIGNORE *(*sprite_get)(struct character *, int, sprite **); + 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; float vx; float vy; -} character; +} akgl_Character; -akerr_ErrorContext AKERR_NOIGNORE *character_initialize(character *basechar, char *name); -akerr_ErrorContext AKERR_NOIGNORE *character_sprite_add(character *basechar, sprite *ref, int state); -akerr_ErrorContext AKERR_NOIGNORE *character_sprite_get(character *basechar, int state, sprite **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_character_initialize(akgl_Character *basechar, char *name); +akerr_ErrorContext AKERR_NOIGNORE *akgl_character_sprite_add(akgl_Character *basechar, akgl_Sprite *ref, int state); +akerr_ErrorContext AKERR_NOIGNORE *akgl_character_sprite_get(akgl_Character *basechar, int state, akgl_Sprite **dest); // This is an SDL iterator so we can't return our error state from it. -void character_state_sprites_iterate(void *userdata, SDL_PropertiesID props, const char *name); +void akgl_character_state_sprites_iterate(void *userdata, SDL_PropertiesID props, const char *name); -akerr_ErrorContext AKERR_NOIGNORE *character_load_json(char *filename); +akerr_ErrorContext AKERR_NOIGNORE *akgl_character_load_json(char *filename); -#endif // _CHARACTER_H_ +#endif // _AKGL_CHARACTER_H_ diff --git a/include/sdl3game/controller.h b/include/sdl3game/controller.h index 091af78..b06d462 100644 --- a/include/sdl3game/controller.h +++ b/include/sdl3game/controller.h @@ -4,8 +4,8 @@ #include #include -#define MAX_CONTROL_MAPS 8 -#define MAX_CONTROLS 32 +#define AKGL_MAX_CONTROL_MAPS 8 +#define AKGL_MAX_CONTROLS 32 typedef struct { Uint32 event_on; @@ -15,30 +15,30 @@ typedef struct { Uint8 axis; Uint8 axis_range_min; Uint8 axis_range_max; - akerr_ErrorContext AKERR_NOIGNORE *(*handler_on)(actor *obj, SDL_Event *event); - akerr_ErrorContext AKERR_NOIGNORE *(*handler_off)(actor *obj, SDL_Event *event); -} SDL3GControl; + 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 { - actor *target; + akgl_Actor *target; int nextMap; - SDL3GControl controls[MAX_CONTROLS]; + akgl_Control controls[AKGL_MAX_CONTROLS]; SDL_KeyboardID kbid; SDL_JoystickID jsid; SDL_MouseID mouseid; SDL_PenID penid; -} SDL3GControlMap; +} akgl_ControlMap; -extern SDL3GControlMap GAME_ControlMaps[MAX_CONTROL_MAPS]; +extern akgl_ControlMap GAME_ControlMaps[AKGL_MAX_CONTROL_MAPS]; -akerr_ErrorContext AKERR_NOIGNORE *controller_handle_event(void *appstate, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_handle_event(void *appstate, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *controller_handle_button_down(void *appstate, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *controller_handle_button_up(void *appstate, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *controller_handle_added(void *appstate, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *controller_handle_removed(void *appstate, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_handle_button_down(void *appstate, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_handle_button_up(void *appstate, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_handle_added(void *appstate, SDL_Event *event); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_handle_removed(void *appstate, SDL_Event *event); -akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_pushmap(int controlmapid, SDL3GControl *control); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_pushmap(int controlmapid, akgl_Control *control); -akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_default(int controlmapid, char *actorname, int kbid, int jsid); +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_default(int controlmapid, char *actorname, int kbid, int jsid); #endif // _CONTROLLER_H_ diff --git a/include/sdl3game/draw.h b/include/sdl3game/draw.h index 31a4259..bce641e 100644 --- a/include/sdl3game/draw.h +++ b/include/sdl3game/draw.h @@ -1,6 +1,6 @@ #ifndef _DRAW_H_ #define _DRAW_H_ -void GAME_draw_background(int w, int h); +void akgl_draw_background(int w, int h); #endif //_DRAW_H_ diff --git a/include/sdl3game/error.h b/include/sdl3game/error.h index 61fccd5..96e5c41 100644 --- a/include/sdl3game/error.h +++ b/include/sdl3game/error.h @@ -1,6 +1,6 @@ #ifndef _ERROR_H_ #define _ERROR_H_ -#define AKERR_SDL AKERR_LAST_ERRNO_VALUE + 1 +#define AKGL_ERR_SDL AKERR_LAST_ERRNO_VALUE + 1 #endif // _ERROR_H_ diff --git a/include/sdl3game/game.h b/include/sdl3game/game.h index 37f6f3a..2a2cf8d 100644 --- a/include/sdl3game/game.h +++ b/include/sdl3game/game.h @@ -1,14 +1,14 @@ -#ifndef _GAME_H_ -#define _GAME_H_ +#ifndef _AKGL_GAME_H_ +#define _AKGL_GAME_H_ #include #include "tilemap.h" -#define GAME_AUDIO_TRACK_BGM 1 -#define GAME_AUDIO_MAX_TRACKS 64 +#define AKGL_GAME_AUDIO_TRACK_BGM 1 +#define AKGL_GAME_AUDIO_MAX_TRACKS 64 -#define TIME_ONESEC_NS 1000000000 -#define TIME_ONESEC_MS 1000000 +#define AKGL_TIME_ONESEC_NS 1000000000 +#define AKGL_TIME_ONESEC_MS 1000000 /* ==================== GAME STATE VARIABLES =================== */ @@ -16,11 +16,11 @@ typedef struct { float w; float h; SDL_Texture *texture; -} GAME_frame; +} akgl_Frame; typedef struct { int flags; -} GameState; +} akgl_GameState; typedef struct { char name[256]; @@ -28,30 +28,30 @@ typedef struct { char uri[256]; int screenwidth; int screenheight; - GameState state; + akgl_GameState state; int fps; SDL_Time gameStartTime; SDL_Time lastIterTime; SDL_Time lastFPSTime; int framesSinceUpdate; MIX_Mixer *mixer; - MIX_Track *tracks[GAME_AUDIO_MAX_TRACKS]; -} Game; + MIX_Track *tracks[AKGL_GAME_AUDIO_MAX_TRACKS]; +} akgl_Game; extern SDL_Window *window; extern SDL_Renderer *renderer; -extern tilemap gamemap; +extern akgl_Tilemap gamemap; extern MIX_Audio *bgm; extern SDL_FRect camera; -extern Game game; +extern akgl_Game game; -#define BITMASK_HAS(x, y) (x & y) == y -#define BITMASK_ADD(x, y) x |= y -#define BITMASK_DEL(x, y) x &= ~(y) -#define BITMASK_CLEAR(x) x = 0; +#define AKGL_BITMASK_HAS(x, y) (x & y) == y +#define AKGL_BITMASK_ADD(x, y) x |= y +#define AKGL_BITMASK_DEL(x, y) x &= ~(y) +#define AKGL_BITMASK_CLEAR(x) x = 0; -akerr_ErrorContext AKERR_NOIGNORE *GAME_init(); -void GAME_updateFPS(); +akerr_ErrorContext AKERR_NOIGNORE *akgl_game_init(); +void akgl_game_updateFPS(); -#endif //_GAME_H_ +#endif //_AKGL_GAME_H_ diff --git a/include/sdl3game/heap.h b/include/sdl3game/heap.h index d2e5856..31634a5 100644 --- a/include/sdl3game/heap.h +++ b/include/sdl3game/heap.h @@ -1,5 +1,5 @@ -#ifndef _HEAP_H_ -#define _HEAP_H_ +#ifndef _AKGL_HEAP_H_ +#define _AKGL_HEAP_H_ #include "sprite.h" #include "actor.h" @@ -7,29 +7,29 @@ #include "staticstring.h" #include -#define MAX_HEAP_ACTOR 64 -#define MAX_HEAP_SPRITE (MAX_HEAP_ACTOR * 16) -#define MAX_HEAP_SPRITESHEET MAX_HEAP_SPRITE -#define MAX_HEAP_CHARACTER 256 -#define MAX_HEAP_STRING 256 +#define AKGL_MAX_HEAP_ACTOR 64 +#define AKGL_MAX_HEAP_SPRITE (AKGL_MAX_HEAP_ACTOR * 16) +#define AKGL_MAX_HEAP_SPRITESHEET AKGL_MAX_HEAP_SPRITE +#define AKGL_MAX_HEAP_CHARACTER 256 +#define AKGL_MAX_HEAP_STRING 256 -extern actor HEAP_ACTOR[MAX_HEAP_ACTOR]; -extern sprite HEAP_SPRITE[MAX_HEAP_SPRITE]; -extern spritesheet HEAP_SPRITESHEET[MAX_HEAP_SPRITESHEET]; -extern character HEAP_CHARACTER[MAX_HEAP_CHARACTER]; -extern string HEAP_STRING[MAX_HEAP_STRING]; +extern akgl_Actor HEAP_ACTOR[AKGL_MAX_HEAP_ACTOR]; +extern akgl_Sprite HEAP_SPRITE[AKGL_MAX_HEAP_SPRITE]; +extern akgl_SpriteSheet HEAP_SPRITESHEET[AKGL_MAX_HEAP_SPRITESHEET]; +extern akgl_Character HEAP_CHARACTER[AKGL_MAX_HEAP_CHARACTER]; +extern akgl_String HEAP_STRING[AKGL_MAX_HEAP_STRING]; -akerr_ErrorContext AKERR_NOIGNORE *heap_init(); -akerr_ErrorContext AKERR_NOIGNORE *heap_next_actor(actor **dest); -akerr_ErrorContext AKERR_NOIGNORE *heap_next_sprite(sprite **dest); -akerr_ErrorContext AKERR_NOIGNORE *heap_next_spritesheet(spritesheet **dest); -akerr_ErrorContext AKERR_NOIGNORE *heap_next_character(character **dest); -akerr_ErrorContext AKERR_NOIGNORE *heap_next_string(string **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_init(); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_next_actor(akgl_Actor **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_next_sprite(akgl_Sprite **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_next_spritesheet(akgl_SpriteSheet **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_next_character(akgl_Character **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_next_string(akgl_String **dest); -akerr_ErrorContext AKERR_NOIGNORE *heap_release_actor(actor *ptr); -akerr_ErrorContext AKERR_NOIGNORE *heap_release_sprite(sprite *ptr); -akerr_ErrorContext AKERR_NOIGNORE *heap_release_spritesheet(spritesheet *ptr); -akerr_ErrorContext AKERR_NOIGNORE *heap_release_character(character *ptr); -akerr_ErrorContext AKERR_NOIGNORE *heap_release_string(string *ptr); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_release_actor(akgl_Actor *ptr); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_release_sprite(akgl_Sprite *ptr); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_release_spritesheet(akgl_SpriteSheet *ptr); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_release_character(akgl_Character *ptr); +akerr_ErrorContext AKERR_NOIGNORE *akgl_heap_release_string(akgl_String *ptr); -#endif //_HEAP_H_ +#endif //_AKGL_HEAP_H_ diff --git a/include/sdl3game/iterator.h b/include/sdl3game/iterator.h index 8de017c..3f3e1ae 100644 --- a/include/sdl3game/iterator.h +++ b/include/sdl3game/iterator.h @@ -1,43 +1,43 @@ -#ifndef _ITERATOR_H_ -#define _ITERATOR_H_ +#ifndef _AKGL_ITERATOR_H_ +#define _AKGL_ITERATOR_H_ typedef struct { int flags; int layerid; -} iterator; +} akgl_Iterator; -#define ITERATOR_OP_UPDATE 1 // 1 -#define ITERATOR_OP_RENDER 1 << 1 // 2 -#define ITERATOR_OP_RELEASE 1 << 2 // 4 -#define ITERATOR_OP_LAYERMASK 1 << 3 // 8 -#define ITERATOR_OP_UNDEFINED_4 1 << 4 // 16 -#define ITERATOR_OP_UNDEFINED_5 1 << 5 // 32 -#define ITERATOR_OP_UNDEFINED_6 1 << 6 // 64 -#define ITERATOR_OP_UNDEFINED_7 1 << 7 // 128 -#define ITERATOR_OP_UNDEFINED_8 1 << 8 // 256 -#define ITERATOR_OP_UNDEFINED_9 1 << 9 // 512 -#define ITERATOR_OP_UNDEFINED_10 1 << 10 // 1024 -#define ITERATOR_OP_UNDEFINED_11 1 << 11 // 2048 -#define ITERATOR_OP_UNDEFINED_12 1 << 12 // 4096 -#define ITERATOR_OP_UNDEFINED_13 1 << 13 // 8192 -#define ITERATOR_OP_UNDEFINED_14 1 << 14 // 16384 -#define ITERATOR_OP_UNDEFINED_15 1 << 15 // 32768 -#define ITERATOR_OP_UNDEFINED_16 1 << 16 // 65536 -#define ITERATOR_OP_UNDEFINED_17 1 << 17 // 131072 -#define ITERATOR_OP_UNDEFINED_18 1 << 18 // 262144 -#define ITERATOR_OP_UNDEFINED_19 1 << 19 // 524288 -#define ITERATOR_OP_UNDEFINED_20 1 << 20 // 1048576 -#define ITERATOR_OP_UNDEFINED_21 1 << 21 // 2097152 -#define ITERATOR_OP_UNDEFINED_22 1 << 22 // 4194304 -#define ITERATOR_OP_UNDEFINED_23 1 << 23 // 8388608 -#define ITERATOR_OP_UNDEFINED_24 1 << 24 // 16777216 -#define ITERATOR_OP_UNDEFINED_25 1 << 25 // 33554432 -#define ITERATOR_OP_UNDEFINED_26 1 << 26 // 67108864 -#define ITERATOR_OP_UNDEFINED_27 1 << 27 // 134217728 -#define ITERATOR_OP_UNDEFINED_28 1 << 28 // 268435456 -#define ITERATOR_OP_UNDEFINED_29 1 << 29 // 536870912 -#define ITERATOR_OP_UNDEFINED_30 1 << 30 // 1073741824 -#define ITERATOR_OP_UNDEFINED_31 1 << 31 // 2147483648 +#define AKGL_ITERATOR_OP_UPDATE 1 // 1 +#define AKGL_ITERATOR_OP_RENDER 1 << 1 // 2 +#define AKGL_ITERATOR_OP_RELEASE 1 << 2 // 4 +#define AKGL_ITERATOR_OP_LAYERMASK 1 << 3 // 8 +#define AKGL_ITERATOR_OP_UNDEFINED_4 1 << 4 // 16 +#define AKGL_ITERATOR_OP_UNDEFINED_5 1 << 5 // 32 +#define AKGL_ITERATOR_OP_UNDEFINED_6 1 << 6 // 64 +#define AKGL_ITERATOR_OP_UNDEFINED_7 1 << 7 // 128 +#define AKGL_ITERATOR_OP_UNDEFINED_8 1 << 8 // 256 +#define AKGL_ITERATOR_OP_UNDEFINED_9 1 << 9 // 512 +#define AKGL_ITERATOR_OP_UNDEFINED_10 1 << 10 // 1024 +#define AKGL_ITERATOR_OP_UNDEFINED_11 1 << 11 // 2048 +#define AKGL_ITERATOR_OP_UNDEFINED_12 1 << 12 // 4096 +#define AKGL_ITERATOR_OP_UNDEFINED_13 1 << 13 // 8192 +#define AKGL_ITERATOR_OP_UNDEFINED_14 1 << 14 // 16384 +#define AKGL_ITERATOR_OP_UNDEFINED_15 1 << 15 // 32768 +#define AKGL_ITERATOR_OP_UNDEFINED_16 1 << 16 // 65536 +#define AKGL_ITERATOR_OP_UNDEFINED_17 1 << 17 // 131072 +#define AKGL_ITERATOR_OP_UNDEFINED_18 1 << 18 // 262144 +#define AKGL_ITERATOR_OP_UNDEFINED_19 1 << 19 // 524288 +#define AKGL_ITERATOR_OP_UNDEFINED_20 1 << 20 // 1048576 +#define AKGL_ITERATOR_OP_UNDEFINED_21 1 << 21 // 2097152 +#define AKGL_ITERATOR_OP_UNDEFINED_22 1 << 22 // 4194304 +#define AKGL_ITERATOR_OP_UNDEFINED_23 1 << 23 // 8388608 +#define AKGL_ITERATOR_OP_UNDEFINED_24 1 << 24 // 16777216 +#define AKGL_ITERATOR_OP_UNDEFINED_25 1 << 25 // 33554432 +#define AKGL_ITERATOR_OP_UNDEFINED_26 1 << 26 // 67108864 +#define AKGL_ITERATOR_OP_UNDEFINED_27 1 << 27 // 134217728 +#define AKGL_ITERATOR_OP_UNDEFINED_28 1 << 28 // 268435456 +#define AKGL_ITERATOR_OP_UNDEFINED_29 1 << 29 // 536870912 +#define AKGL_ITERATOR_OP_UNDEFINED_30 1 << 30 // 1073741824 +#define AKGL_ITERATOR_OP_UNDEFINED_31 1 << 31 // 2147483648 -#endif // _ITERATOR_H_ +#endif // _AKGL_ITERATOR_H_ diff --git a/include/sdl3game/json_helpers.h b/include/sdl3game/json_helpers.h index 23faf74..227f925 100644 --- a/include/sdl3game/json_helpers.h +++ b/include/sdl3game/json_helpers.h @@ -4,14 +4,14 @@ #include #include "staticstring.h" -akerr_ErrorContext AKERR_NOIGNORE *get_json_object_value(json_t *obj, char *key, json_t **dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_boolean_value(json_t *obj, char *key, bool *dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_integer_value(json_t *obj, char *key, int *dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_number_value(json_t *obj, char *key, float *dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_string_value(json_t *obj, char *key, string **dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_array_value(json_t *obj, char *key, json_t **dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_array_index_object(json_t *array, int index, json_t **dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_array_index_integer(json_t *array, int index, int *dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_array_index_string(json_t *array, int index, string **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_object_value(json_t *obj, char *key, json_t **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_boolean_value(json_t *obj, char *key, bool *dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_integer_value(json_t *obj, char *key, int *dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_number_value(json_t *obj, char *key, float *dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_string_value(json_t *obj, char *key, akgl_String **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_array_value(json_t *obj, char *key, json_t **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_array_index_object(json_t *array, int index, json_t **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_array_index_integer(json_t *array, int index, int *dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_array_index_string(json_t *array, int index, akgl_String **dest); #endif // _JSON_HELPERS_H_ diff --git a/include/sdl3game/registry.h b/include/sdl3game/registry.h index 3f1e6fe..030aba5 100644 --- a/include/sdl3game/registry.h +++ b/include/sdl3game/registry.h @@ -3,22 +3,22 @@ #include "error.h" -extern SDL_PropertiesID REGISTRY_ACTOR; -extern SDL_PropertiesID REGISTRY_SPRITE; -extern SDL_PropertiesID REGISTRY_SPRITESHEET; -extern SDL_PropertiesID REGISTRY_CHARACTER; -extern SDL_PropertiesID REGISTRY_ACTOR_STATE_STRINGS; -extern SDL_PropertiesID REGISTRY_FONT; -extern SDL_PropertiesID REGISTRY_MUSIC; +extern SDL_PropertiesID AKGL_REGISTRY_ACTOR; +extern SDL_PropertiesID AKGL_REGISTRY_SPRITE; +extern SDL_PropertiesID AKGL_AKGL_REGISTRY_SPRITESHEET; +extern SDL_PropertiesID AKGL_REGISTRY_CHARACTER; +extern SDL_PropertiesID AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS; +extern SDL_PropertiesID AKGL_REGISTRY_FONT; +extern SDL_PropertiesID AKGL_REGISTRY_MUSIC; -akerr_ErrorContext AKERR_NOIGNORE *registry_init(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_music(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_font(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_actor(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_sprite(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_spritesheet(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_character(); -akerr_ErrorContext AKERR_NOIGNORE *registry_init_actor_state_strings(); +akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init(); +akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_music(); +akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_font(); +akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_actor(); +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_actor_state_strings(); #endif //_REGISTRY_H_ diff --git a/include/sdl3game/sprite.h b/include/sdl3game/sprite.h index 0e3d19e..2d0e8e6 100644 --- a/include/sdl3game/sprite.h +++ b/include/sdl3game/sprite.h @@ -1,44 +1,44 @@ -#ifndef _SPRITE_H_ -#define _SPRITE_H_ +#ifndef _AKGL_SPRITE_H_ +#define _AKGL_SPRITE_H_ #include #include #include -#define SPRITE_MAX_FRAMES 16 -#define SPRITE_MAX_NAME_LENGTH 128 -#define SPRITE_MAX_REGISTRY_SIZE 1024 -#define SPRITE_SHEET_MAX_FILENAME_LENGTH 512 +#define AKGL_SPRITE_MAX_FRAMES 16 +#define AKGL_SPRITE_MAX_NAME_LENGTH 128 +#define AKGL_SPRITE_MAX_REGISTRY_SIZE 1024 +#define AKGL_SPRITE_SHEET_MAX_FILENAME_LENGTH 512 -#define MAX_HEAP_SPRITE (MAX_HEAP_ACTOR * 16) -#define MAX_HEAP_SPRITESHEET MAX_HEAP_SPRITE +#define AKGL_MAX_HEAP_SPRITE (AKGL_MAX_HEAP_ACTOR * 16) +#define AKGL_MAX_HEAP_SPRITESHEET AKGL_MAX_HEAP_SPRITE typedef struct { int refcount; SDL_Texture *texture; - char name[SPRITE_SHEET_MAX_FILENAME_LENGTH]; + char name[AKGL_SPRITE_SHEET_MAX_FILENAME_LENGTH]; int sprite_w; int sprite_h; -} spritesheet; +} akgl_SpriteSheet; typedef struct { int refcount; - spritesheet *sheet; - int frameids[SPRITE_MAX_FRAMES]; // which IDs on the spritesheet belong to our frames + akgl_SpriteSheet *sheet; + int frameids[AKGL_SPRITE_MAX_FRAMES]; // which IDs on the spritesheet belong to our frames int frames; // how many frames are in this animation int width; int height; long int 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 loopReverse; // when this sprite is done playing, it should go in reverse order through its frames - char name[SPRITE_MAX_NAME_LENGTH]; -} sprite; + char name[AKGL_SPRITE_MAX_NAME_LENGTH]; +} akgl_Sprite; // initializes a new sprite to use the given sheet and otherwise sets to zero -akerr_ErrorContext AKERR_NOIGNORE *sprite_initialize(sprite *spr, char *name, spritesheet *sheet); +akerr_ErrorContext AKERR_NOIGNORE *akgl_sprite_initialize(akgl_Sprite *spr, char *name, akgl_SpriteSheet *sheet); // loads a given image file into a new spritesheet -akerr_ErrorContext AKERR_NOIGNORE *spritesheet_initialize(spritesheet *sheet, int sprite_w, int sprite_h, char *filename); -akerr_ErrorContext AKERR_NOIGNORE *sprite_load_json(char *filename); +akerr_ErrorContext AKERR_NOIGNORE *akgl_spritesheet_initialize(akgl_SpriteSheet *sheet, int sprite_w, int sprite_h, char *filename); +akerr_ErrorContext AKERR_NOIGNORE *akgl_sprite_load_json(char *filename); -#endif //_SPRITE_H_ +#endif //_AKGL_SPRITE_H_ diff --git a/include/sdl3game/staticstring.h b/include/sdl3game/staticstring.h index fd79a52..6cb1d03 100644 --- a/include/sdl3game/staticstring.h +++ b/include/sdl3game/staticstring.h @@ -4,14 +4,14 @@ #include "string.h" #include -#define MAX_STRING_LENGTH 256 +#define AKGL_MAX_STRING_LENGTH 256 typedef struct { int refcount; - char data[MAX_STRING_LENGTH]; -} string; + char data[AKGL_MAX_STRING_LENGTH]; +} akgl_String; -akerr_ErrorContext AKERR_NOIGNORE *string_initialize(string *obj, char *init); +akerr_ErrorContext AKERR_NOIGNORE *akgl_string_initialize(akgl_String *obj, char *init); #endif //_STRING_H_ diff --git a/include/sdl3game/text.h b/include/sdl3game/text.h index ffb7154..5298797 100644 --- a/include/sdl3game/text.h +++ b/include/sdl3game/text.h @@ -3,7 +3,7 @@ #include -akerr_ErrorContext AKERR_NOIGNORE *text_loadFont(char *name, char *filepath, int size); -akerr_ErrorContext AKERR_NOIGNORE *text_renderTextAt(TTF_Font *font, char *text, SDL_Color color, int wraplength, int x, int y); +akerr_ErrorContext AKERR_NOIGNORE *akgl_text_loadfont(char *name, char *filepath, int size); +akerr_ErrorContext AKERR_NOIGNORE *akgl_text_rendertextat(TTF_Font *font, char *text, SDL_Color color, int wraplength, int x, int y); #endif // _TEXT_H_ diff --git a/include/sdl3game/tilemap.h b/include/sdl3game/tilemap.h index 8e15a4e..3343eec 100644 --- a/include/sdl3game/tilemap.h +++ b/include/sdl3game/tilemap.h @@ -5,20 +5,20 @@ #include "staticstring.h" #include -#define TILEMAP_MAX_WIDTH 512 -#define TILEMAP_MAX_HEIGHT 512 -#define TILEMAP_MAX_LAYERS 16 -#define TILEMAP_MAX_TILESETS 16 -#define TILEMAP_MAX_TILES_PER_IMAGE 65536 -#define TILEMAP_MAX_TILESET_NAME_SIZE 512 -#define TILEMAP_MAX_TILESET_FILENAME_SIZE 512 -#define TILEMAP_MAX_OBJECT_NAME_SIZE 512 -#define TILEMAP_MAX_OBJECTS_PER_LAYER 128 +#define AKGL_TILEMAP_MAX_WIDTH 512 +#define AKGL_TILEMAP_MAX_HEIGHT 512 +#define AKGL_TILEMAP_MAX_LAYERS 16 +#define AKGL_TILEMAP_MAX_TILESETS 16 +#define AKGL_TILEMAP_MAX_TILES_PER_IMAGE 65536 +#define AKGL_TILEMAP_MAX_TILESET_NAME_SIZE 512 +#define AKGL_TILEMAP_MAX_TILESET_FILENAME_SIZE 512 +#define AKGL_TILEMAP_MAX_OBJECT_NAME_SIZE 512 +#define AKGL_TILEMAP_MAX_OBJECTS_PER_LAYER 128 -#define TILEMAP_OBJECT_TYPE_ACTOR 1 +#define AKGL_TILEMAP_OBJECT_TYPE_ACTOR 1 -#define TILEMAP_LAYER_TYPE_TILES 1 -#define TILEMAP_LAYER_TYPE_OBJECTS 2 +#define AKGL_TILEMAP_LAYER_TYPE_TILES 1 +#define AKGL_TILEMAP_LAYER_TYPE_OBJECTS 2 typedef struct { float x; @@ -30,9 +30,9 @@ typedef struct { int rotation; int type; bool visible; - actor *actorptr; - char name[TILEMAP_MAX_OBJECT_NAME_SIZE]; -} tilemap_object; + akgl_Actor *actorptr; + char name[AKGL_TILEMAP_MAX_OBJECT_NAME_SIZE]; +} akgl_TilemapObject; typedef struct { short type; @@ -43,17 +43,17 @@ typedef struct { int x; int y; int id; - int data[TILEMAP_MAX_WIDTH * TILEMAP_MAX_HEIGHT]; - tilemap_object objects[TILEMAP_MAX_OBJECTS_PER_LAYER]; -} tilemap_layer; + int data[AKGL_TILEMAP_MAX_WIDTH * AKGL_TILEMAP_MAX_HEIGHT]; + akgl_TilemapObject objects[AKGL_TILEMAP_MAX_OBJECTS_PER_LAYER]; +} akgl_TilemapLayer; typedef struct { int columns; int firstgid; - char imagefilename[TILEMAP_MAX_TILESET_FILENAME_SIZE]; + char imagefilename[AKGL_TILEMAP_MAX_TILESET_FILENAME_SIZE]; int imageheight; int imagewidth; - char name[TILEMAP_MAX_TILESET_NAME_SIZE]; + char name[AKGL_TILEMAP_MAX_TILESET_NAME_SIZE]; SDL_Texture *texture; // Use this as a lookup table instead of storing tiles // in individual textures to blit them from a single @@ -64,18 +64,18 @@ typedef struct { // and have 1728 tiles. Set B may start at firstgid 1729 and // have 1728 more tiles. This means Set B has 1728 empty // tile_offsets[] entries before firstgid 1729 because of the - // way tilemap_load_tilesets() works. This is really inefficient + // way akgl_tilemap_load_tilesets() works. This is really inefficient // and should be improved in the future, and will eventually - // lead to premature exhaustion of TILEMAP_MAX_TILES_PER_IMAGE + // lead to premature exhaustion of AKGL_TILEMAP_MAX_TILES_PER_IMAGE // because set D or E may only have 64 tiles but they may be // at the upper end of the array bound already because of this. - int tile_offsets[TILEMAP_MAX_TILES_PER_IMAGE][2]; + int tile_offsets[AKGL_TILEMAP_MAX_TILES_PER_IMAGE][2]; int tilecount; int tileheight; int tilewidth; int spacing; int margin; -} tileset; +} akgl_Tileset; typedef struct { int tilewidth; @@ -85,28 +85,28 @@ typedef struct { int numlayers; int orientation; // 0 = orthogonal, 1 = isometric int numtilesets; - tileset tilesets[TILEMAP_MAX_TILESETS]; - tilemap_layer layers[TILEMAP_MAX_LAYERS]; -} tilemap; + akgl_Tileset tilesets[AKGL_TILEMAP_MAX_TILESETS]; + akgl_TilemapLayer layers[AKGL_TILEMAP_MAX_LAYERS]; +} akgl_Tilemap; -akerr_ErrorContext AKERR_NOIGNORE *tilemap_load(char *fname, tilemap *dest); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_draw(SDL_Renderer *renderer, tilemap *dest, SDL_FRect *viewport, int layeridx); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_draw_tileset(SDL_Renderer *renderer, tilemap *dest, int tilesetidx); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_load(char *fname, akgl_Tilemap *dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_draw(SDL_Renderer *renderer, akgl_Tilemap *dest, SDL_FRect *viewport, int layeridx); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_draw_tileset(SDL_Renderer *renderer, akgl_Tilemap *dest, int tilesetidx); /* * These functions are part of the internal API and should not be called by the user. * They are only exposed here for unit testing. */ -akerr_ErrorContext AKERR_NOIGNORE *get_json_tilemap_property(json_t *obj, char *key, char *type, json_t **dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_properties_string(json_t *obj, char *key, string **dest); -akerr_ErrorContext AKERR_NOIGNORE *get_json_properties_integer(json_t *obj, char *key, int *dest); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_compute_tileset_offsets(tilemap *dest, int tilesetidx); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_load_layer_objects(tilemap *dest, json_t *root, int layerid); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_load_layer_tile(tilemap *dest, json_t *root, int layerid); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_load_layers(tilemap *dest, json_t *root); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_load_tilesets_each(json_t *tileset, tilemap *dest, int tsidx); -akerr_ErrorContext AKERR_NOIGNORE *tilemap_load_tilesets(tilemap *dest, json_t *root); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_tilemap_property(json_t *obj, char *key, char *type, json_t **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_properties_string(json_t *obj, char *key, akgl_String **dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_get_json_properties_integer(json_t *obj, char *key, int *dest); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_compute_tileset_offsets(akgl_Tilemap *dest, int tilesetidx); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_load_layer_objects(akgl_Tilemap *dest, json_t *root, int layerid); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_load_layer_tile(akgl_Tilemap *dest, json_t *root, int layerid); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_load_layers(akgl_Tilemap *dest, json_t *root); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_load_tilesets_each(json_t *tileset, akgl_Tilemap *dest, int tsidx); +akerr_ErrorContext AKERR_NOIGNORE *akgl_tilemap_load_tilesets(akgl_Tilemap *dest, json_t *root); #endif //_TILEMAP_H_ diff --git a/include/sdl3game/util.h b/include/sdl3game/util.h index 1cfdafd..f59f0b0 100644 --- a/include/sdl3game/util.h +++ b/include/sdl3game/util.h @@ -16,14 +16,14 @@ typedef struct RectanglePoints { point bottomright; } RectanglePoints; -#define COLLIDE_RECTANGLES(r1x, r1y, r1w, r1h, r2x, r2y, r2w, r2h) ((r1x < (r2x + r2w)) || ((r1x + r1w) > r2x) +#define AKGL_COLLIDE_RECTANGLES(r1x, r1y, r1w, r1h, r2x, r2y, r2w, r2h) ((r1x < (r2x + r2w)) || ((r1x + r1w) > r2x) -akerr_ErrorContext AKERR_NOIGNORE *rectangle_points(RectanglePoints *dest, SDL_FRect *rect); -akerr_ErrorContext AKERR_NOIGNORE *collide_point_rectangle(point *p, RectanglePoints *r, bool *collide); -akerr_ErrorContext AKERR_NOIGNORE *collide_rectangles(SDL_FRect *r1, SDL_FRect *r2, bool *collide); +akerr_ErrorContext AKERR_NOIGNORE *akgl_rectangle_points(RectanglePoints *dest, SDL_FRect *rect); +akerr_ErrorContext AKERR_NOIGNORE *akgl_collide_point_rectangle(point *p, RectanglePoints *r, bool *collide); +akerr_ErrorContext AKERR_NOIGNORE *akgl_collide_rectangles(SDL_FRect *r1, SDL_FRect *r2, bool *collide); // These are REALLY slow routines that are only useful in testing harnesses -akerr_ErrorContext AKERR_NOIGNORE *compare_sdl_surfaces(SDL_Surface *s1, SDL_Surface *s2); -akerr_ErrorContext AKERR_NOIGNORE *render_and_compare(SDL_Texture *t1, SDL_Texture *t2, int x, int y, int w, int h, char *writeout); +akerr_ErrorContext AKERR_NOIGNORE *akgl_compare_sdl_surfaces(SDL_Surface *s1, SDL_Surface *s2); +akerr_ErrorContext AKERR_NOIGNORE *akgl_render_and_compare(SDL_Texture *t1, SDL_Texture *t2, int x, int y, int w, int h, char *writeout); #endif // _UTIL_H_ diff --git a/mkcontrollermappings.sh b/mkcontrollermappings.sh index 5d4fc90..df74dd3 100755 --- a/mkcontrollermappings.sh +++ b/mkcontrollermappings.sh @@ -10,7 +10,7 @@ cat > ../include/sdl3game/SDL_GameControllerDB.h < #include -akerr_ErrorContext *actor_initialize(actor *obj, char *name) +akerr_ErrorContext *akgl_actor_initialize(akgl_Actor *obj, char *name) { PREPARE_ERROR(errctx); - FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "actor_initialize received null actor pointer"); - FAIL_ZERO_RETURN(errctx, name, AKERR_NULLPOINTER, "actor_initialize received null name string pointer"); + FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "akgl_actor_initialize received null actor pointer"); + FAIL_ZERO_RETURN(errctx, name, AKERR_NULLPOINTER, "akgl_actor_initialize received null name string pointer"); - memset(obj, 0x00, sizeof(actor)); - strncpy((char *)obj->name, name, ACTOR_MAX_NAME_LENGTH); + memset(obj, 0x00, sizeof(akgl_Actor)); + strncpy((char *)obj->name, name, AKGL_ACTOR_MAX_NAME_LENGTH); obj->curSpriteReversing = false; obj->movement_controls_face = true; - obj->updatefunc = &actor_update; - obj->renderfunc = &actor_render; - obj->facefunc = &actor_automatic_face; - obj->movementlogicfunc = &actor_logic_movement; - obj->changeframefunc = &actor_logic_changeframe; - obj->addchild = &actor_add_child; + obj->updatefunc = &akgl_actor_update; + obj->renderfunc = &akgl_actor_render; + obj->facefunc = &akgl_actor_automatic_face; + obj->movementlogicfunc = &akgl_actor_logic_movement; + obj->changeframefunc = &akgl_actor_logic_changeframe; + obj->addchild = &akgl_actor_add_child; FAIL_ZERO_RETURN( errctx, - SDL_SetPointerProperty(REGISTRY_ACTOR, name, (void *)obj), + SDL_SetPointerProperty(AKGL_REGISTRY_ACTOR, name, (void *)obj), AKERR_KEY, "Unable to add actor to registry" ); @@ -40,34 +40,34 @@ akerr_ErrorContext *actor_initialize(actor *obj, char *name) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_set_character(actor *obj, char *basecharname) +akerr_ErrorContext *akgl_actor_set_character(akgl_Actor *obj, char *basecharname) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "Null actor reference"); FAIL_ZERO_RETURN(errctx, basecharname, AKERR_NULLPOINTER, "Null character reference"); - obj->basechar = SDL_GetPointerProperty(REGISTRY_CHARACTER, basecharname, NULL); + obj->basechar = SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, basecharname, NULL); FAIL_ZERO_RETURN(errctx, obj->basechar, AKERR_NULLPOINTER, "Character not found in the registry"); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_automatic_face(actor *obj) +akerr_ErrorContext *akgl_actor_automatic_face(akgl_Actor *obj) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "Null actor reference"); ATTEMPT { if ( obj->movement_controls_face == true ) { // TODO : This doesn't really work properly - BITMASK_DEL(obj->state, ACTOR_STATE_FACE_ALL); - if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_LEFT) ) { - BITMASK_ADD(obj->state, ACTOR_STATE_FACE_LEFT); - } else if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_RIGHT) ) { - BITMASK_ADD(obj->state, ACTOR_STATE_FACE_RIGHT); - } else if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_UP) ) { - BITMASK_ADD(obj->state, ACTOR_STATE_FACE_UP); - } else if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_DOWN) ) { - BITMASK_ADD(obj->state, ACTOR_STATE_FACE_DOWN); + AKGL_BITMASK_DEL(obj->state, AKGL_ACTOR_STATE_FACE_ALL); + if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_LEFT) ) { + AKGL_BITMASK_ADD(obj->state, AKGL_ACTOR_STATE_FACE_LEFT); + } else if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_RIGHT) ) { + AKGL_BITMASK_ADD(obj->state, AKGL_ACTOR_STATE_FACE_RIGHT); + } else if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_UP) ) { + AKGL_BITMASK_ADD(obj->state, AKGL_ACTOR_STATE_FACE_UP); + } else if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_DOWN) ) { + AKGL_BITMASK_ADD(obj->state, AKGL_ACTOR_STATE_FACE_DOWN); } } } CLEANUP { @@ -76,7 +76,7 @@ akerr_ErrorContext *actor_automatic_face(actor *obj) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_logic_changeframe(actor *obj, sprite *curSprite, SDL_Time curtime) +akerr_ErrorContext *akgl_actor_logic_changeframe(akgl_Actor *obj, akgl_Sprite *curSprite, SDL_Time curtime) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "Null actor reference"); @@ -111,7 +111,7 @@ akerr_ErrorContext *actor_logic_changeframe(actor *obj, sprite *curSprite, SDL_T SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_logic_movement(actor *obj, SDL_Time curtime) +akerr_ErrorContext *akgl_actor_logic_movement(akgl_Actor *obj, SDL_Time curtime) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "Null actor reference"); @@ -119,27 +119,27 @@ akerr_ErrorContext *actor_logic_movement(actor *obj, SDL_Time curtime) // Children don't move independently of their parents, they just have an offset SUCCEED_RETURN(errctx); } else { - if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_LEFT) ) { + if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_LEFT) ) { obj->x -= obj->basechar->vx; } - if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_RIGHT) ) { + if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_RIGHT) ) { obj->x += obj->basechar->vx; } - if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_UP) ) { + if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_UP) ) { obj->y -= obj->basechar->vy; } - if ( BITMASK_HAS(obj->state, ACTOR_STATE_MOVING_DOWN) ) { + if ( AKGL_BITMASK_HAS(obj->state, AKGL_ACTOR_STATE_MOVING_DOWN) ) { obj->y += obj->basechar->vy; } } SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_update(actor *obj) +akerr_ErrorContext *akgl_actor_update(akgl_Actor *obj) { PREPARE_ERROR(errctx); SDL_Time curtime = 0; - sprite *curSprite = NULL; + akgl_Sprite *curSprite = NULL; FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor reference"); FAIL_ZERO_RETURN(errctx, obj->basechar, AKERR_NULLPOINTER, "Actor has NULL base character reference"); @@ -157,7 +157,7 @@ akerr_ErrorContext *actor_update(actor *obj) } FINISH(errctx, false); ATTEMPT { - CATCH(errctx, character_sprite_get(obj->basechar, obj->state, &curSprite)); + CATCH(errctx, akgl_character_sprite_get(obj->basechar, obj->state, &curSprite)); // is it time to change frames? if ( ((curtime) - obj->curSpriteFrameTimer) >= curSprite->speed) { CATCH(errctx, obj->changeframefunc(obj, curSprite, curtime)); @@ -172,17 +172,17 @@ akerr_ErrorContext *actor_update(actor *obj) SUCCEED_RETURN(errctx); } -static akerr_ErrorContext *actor_visible(actor *obj, SDL_FRect *camera, bool *visible) +static akerr_ErrorContext *actor_visible(akgl_Actor *obj, SDL_FRect *camera, bool *visible) { PREPARE_ERROR(errctx); - sprite *curSprite = NULL; + akgl_Sprite *curSprite = NULL; FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, renderer, AKERR_NULLPOINTER, "NULL renderer"); FAIL_ZERO_RETURN(errctx, obj->basechar, AKERR_NULLPOINTER, "Actor has NULL base character reference"); ATTEMPT { - CATCH(errctx, character_sprite_get(obj->basechar, obj->state, &curSprite)); + CATCH(errctx, akgl_character_sprite_get(obj->basechar, obj->state, &curSprite)); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_KEY) { @@ -202,10 +202,10 @@ static akerr_ErrorContext *actor_visible(actor *obj, SDL_FRect *camera, bool *vi SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_render(actor *obj, SDL_Renderer *renderer) +akerr_ErrorContext *akgl_actor_render(akgl_Actor *obj, SDL_Renderer *renderer) { PREPARE_ERROR(errctx); - sprite *curSprite = NULL; + akgl_Sprite *curSprite = NULL; bool visible = false; SDL_FRect src; SDL_FRect dest; @@ -215,7 +215,7 @@ akerr_ErrorContext *actor_render(actor *obj, SDL_Renderer *renderer) FAIL_ZERO_RETURN(errctx, obj->basechar, AKERR_NULLPOINTER, "Actor has NULL base character reference"); ATTEMPT { - CATCH(errctx, character_sprite_get(obj->basechar, obj->state, &curSprite)); + CATCH(errctx, akgl_character_sprite_get(obj->basechar, obj->state, &curSprite)); CATCH(errctx, actor_visible(obj, &camera, &visible)); } CLEANUP { } PROCESS(errctx) { @@ -259,7 +259,7 @@ akerr_ErrorContext *actor_render(actor *obj, SDL_Renderer *renderer) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *actor_add_child(actor *obj, actor *child) +akerr_ErrorContext *akgl_actor_add_child(akgl_Actor *obj, akgl_Actor *child) { int i = 0; PREPARE_ERROR(errctx); @@ -267,7 +267,7 @@ akerr_ErrorContext *actor_add_child(actor *obj, actor *child) FAIL_ZERO_RETURN(errctx, child, AKERR_NULLPOINTER, "NULL child pointer"); FAIL_NONZERO_RETURN(errctx, child->parent, AKERR_RELATIONSHIP, "Child object already has a parent"); - for ( i = 0; i < ACTOR_MAX_CHILDREN ; i++ ) { + for ( i = 0; i < AKGL_ACTOR_MAX_CHILDREN ; i++ ) { if ( obj->children[i] == NULL ) { obj->children[i] = child; child->parent = obj; @@ -280,25 +280,25 @@ akerr_ErrorContext *actor_add_child(actor *obj, actor *child) // SDL iterator so we can't return error information here, void only // this means we don't have anywhere to send exceptions up to, so if we hit an error, we log and exit(1) here -void registry_iterate_actor(void *userdata, SDL_PropertiesID registry, const char *name) +void akgl_registry_iterate_actor(void *userdata, SDL_PropertiesID registry, const char *name) { PREPARE_ERROR(errctx); - iterator *opflags = (iterator *)userdata; + akgl_Iterator *opflags = (akgl_Iterator *)userdata; ATTEMPT { FAIL_ZERO_BREAK(errctx, name, AKERR_NULLPOINTER, "registry_iterate_actor received NULL property name"); FAIL_ZERO_BREAK(errctx, opflags, AKERR_NULLPOINTER, "received NULL iterator flags"); - actor *obj = (actor *)SDL_GetPointerProperty(registry, name, NULL); + akgl_Actor *obj = (akgl_Actor *)SDL_GetPointerProperty(registry, name, NULL); FAIL_ZERO_BREAK(errctx, obj, AKERR_KEY, "registry_iterate_actor received property name that was not in the registry"); - if ( BITMASK_HAS(opflags->flags, ITERATOR_OP_LAYERMASK) ) { + if ( AKGL_BITMASK_HAS(opflags->flags, AKGL_ITERATOR_OP_LAYERMASK) ) { if ( obj->layer != opflags->layerid ) { break; } } - if ( BITMASK_HAS(opflags->flags, ITERATOR_OP_UPDATE) ) { + if ( AKGL_BITMASK_HAS(opflags->flags, AKGL_ITERATOR_OP_UPDATE) ) { CATCH(errctx, obj->updatefunc(obj)); } - if ( BITMASK_HAS(opflags->flags, ITERATOR_OP_RENDER) ) { + if ( AKGL_BITMASK_HAS(opflags->flags, AKGL_ITERATOR_OP_RENDER) ) { CATCH(errctx, obj->renderfunc(obj, renderer)); } } CLEANUP { @@ -306,94 +306,94 @@ void registry_iterate_actor(void *userdata, SDL_PropertiesID registry, const cha } FINISH_NORETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_left_on(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_left_on(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) moves actor left", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, (ACTOR_STATE_FACE_ALL | ACTOR_STATE_MOVING_ALL)); - BITMASK_ADD(obj->state, (ACTOR_STATE_MOVING_LEFT | ACTOR_STATE_FACE_LEFT)); + AKGL_BITMASK_DEL(obj->state, (AKGL_ACTOR_STATE_FACE_ALL | AKGL_ACTOR_STATE_MOVING_ALL)); + AKGL_BITMASK_ADD(obj->state, (AKGL_ACTOR_STATE_MOVING_LEFT | AKGL_ACTOR_STATE_FACE_LEFT)); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_left_off(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_left_off(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) stops moving actor left", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, ACTOR_STATE_MOVING_LEFT); + AKGL_BITMASK_DEL(obj->state, AKGL_ACTOR_STATE_MOVING_LEFT); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_right_on(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_right_on(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) moves actor right", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, (ACTOR_STATE_FACE_ALL | ACTOR_STATE_MOVING_ALL)); - BITMASK_ADD(obj->state, (ACTOR_STATE_MOVING_RIGHT | ACTOR_STATE_FACE_RIGHT)); + AKGL_BITMASK_DEL(obj->state, (AKGL_ACTOR_STATE_FACE_ALL | AKGL_ACTOR_STATE_MOVING_ALL)); + AKGL_BITMASK_ADD(obj->state, (AKGL_ACTOR_STATE_MOVING_RIGHT | AKGL_ACTOR_STATE_FACE_RIGHT)); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_right_off(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_right_off(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) stops moving actor right", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, ACTOR_STATE_MOVING_RIGHT); + AKGL_BITMASK_DEL(obj->state, AKGL_ACTOR_STATE_MOVING_RIGHT); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_up_on(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_up_on(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) moves actor up", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, (ACTOR_STATE_FACE_ALL | ACTOR_STATE_MOVING_ALL)); - BITMASK_ADD(obj->state, (ACTOR_STATE_FACE_UP | ACTOR_STATE_MOVING_UP)); + AKGL_BITMASK_DEL(obj->state, (AKGL_ACTOR_STATE_FACE_ALL | AKGL_ACTOR_STATE_MOVING_ALL)); + AKGL_BITMASK_ADD(obj->state, (AKGL_ACTOR_STATE_FACE_UP | AKGL_ACTOR_STATE_MOVING_UP)); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_up_off(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_up_off(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) stops moving actor up", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, ACTOR_STATE_MOVING_UP); + AKGL_BITMASK_DEL(obj->state, AKGL_ACTOR_STATE_MOVING_UP); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_down_on(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_down_on(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) moves actor down", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, (ACTOR_STATE_FACE_ALL | ACTOR_STATE_MOVING_ALL)); - BITMASK_ADD(obj->state, (ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_DOWN)); + AKGL_BITMASK_DEL(obj->state, (AKGL_ACTOR_STATE_FACE_ALL | AKGL_ACTOR_STATE_MOVING_ALL)); + AKGL_BITMASK_ADD(obj->state, (AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_DOWN)); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3GActor_cmhf_down_off(actor *obj, SDL_Event *event) +akerr_ErrorContext AKERR_NOIGNORE *akgl_Actor_cmhf_down_off(akgl_Actor *obj, SDL_Event *event) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL actor"); FAIL_ZERO_RETURN(errctx, event, AKERR_NULLPOINTER, "NULL event"); //SDL_Log("event %d (button %d / key %d) stops moving actor down", event->type, event->gbutton.which, event->key.key); - BITMASK_DEL(obj->state, ACTOR_STATE_MOVING_DOWN); + AKGL_BITMASK_DEL(obj->state, AKGL_ACTOR_STATE_MOVING_DOWN); //SDL_Log("new target actor state: %b", obj->state); SUCCEED_RETURN(errctx); } diff --git a/src/actor_state_string_names.c b/src/actor_state_string_names.c index 0c76a92..7991289 100644 --- a/src/actor_state_string_names.c +++ b/src/actor_state_string_names.c @@ -1,34 +1,34 @@ -char *ACTOR_STATE_STRING_NAMES[32] = { - "ACTOR_STATE_FACE_DOWN", - "ACTOR_STATE_FACE_LEFT", - "ACTOR_STATE_FACE_RIGHT", - "ACTOR_STATE_FACE_UP", - "ACTOR_STATE_ALIVE", - "ACTOR_STATE_DYING", - "ACTOR_STATE_DEAD", - "ACTOR_STATE_MOVING_LEFT", - "ACTOR_STATE_MOVING_RIGHT", - "ACTOR_STATE_MOVING_UP", - "ACTOR_STATE_MOVING_DOWN", - "ACTOR_STATE_UNDEFINED_11", - "ACTOR_STATE_UNDEFINED_12", - "ACTOR_STATE_UNDEFINED_13", - "ACTOR_STATE_UNDEFINED_14", - "ACTOR_STATE_UNDEFINED_15", - "ACTOR_STATE_UNDEFINED_16", - "ACTOR_STATE_UNDEFINED_17", - "ACTOR_STATE_UNDEFINED_18", - "ACTOR_STATE_UNDEFINED_19", - "ACTOR_STATE_UNDEFINED_20", - "ACTOR_STATE_UNDEFINED_21", - "ACTOR_STATE_UNDEFINED_22", - "ACTOR_STATE_UNDEFINED_23", - "ACTOR_STATE_UNDEFINED_24", - "ACTOR_STATE_UNDEFINED_25", - "ACTOR_STATE_UNDEFINED_26", - "ACTOR_STATE_UNDEFINED_27", - "ACTOR_STATE_UNDEFINED_28", - "ACTOR_STATE_UNDEFINED_29", - "ACTOR_STATE_UNDEFINED_30", - "ACTOR_STATE_UNDEFINED_31", +char *AKGL_ACTOR_STATE_STRING_NAMES[32] = { + "AKGL_ACTOR_STATE_FACE_DOWN", + "AKGL_ACTOR_STATE_FACE_LEFT", + "AKGL_ACTOR_STATE_FACE_RIGHT", + "AKGL_ACTOR_STATE_FACE_UP", + "AKGL_ACTOR_STATE_ALIVE", + "AKGL_ACTOR_STATE_DYING", + "AKGL_ACTOR_STATE_DEAD", + "AKGL_ACTOR_STATE_MOVING_LEFT", + "AKGL_ACTOR_STATE_MOVING_RIGHT", + "AKGL_ACTOR_STATE_MOVING_UP", + "AKGL_ACTOR_STATE_MOVING_DOWN", + "AKGL_ACTOR_STATE_UNDEFINED_11", + "AKGL_ACTOR_STATE_UNDEFINED_12", + "AKGL_ACTOR_STATE_UNDEFINED_13", + "AKGL_ACTOR_STATE_UNDEFINED_14", + "AKGL_ACTOR_STATE_UNDEFINED_15", + "AKGL_ACTOR_STATE_UNDEFINED_16", + "AKGL_ACTOR_STATE_UNDEFINED_17", + "AKGL_ACTOR_STATE_UNDEFINED_18", + "AKGL_ACTOR_STATE_UNDEFINED_19", + "AKGL_ACTOR_STATE_UNDEFINED_20", + "AKGL_ACTOR_STATE_UNDEFINED_21", + "AKGL_ACTOR_STATE_UNDEFINED_22", + "AKGL_ACTOR_STATE_UNDEFINED_23", + "AKGL_ACTOR_STATE_UNDEFINED_24", + "AKGL_ACTOR_STATE_UNDEFINED_25", + "AKGL_ACTOR_STATE_UNDEFINED_26", + "AKGL_ACTOR_STATE_UNDEFINED_27", + "AKGL_ACTOR_STATE_UNDEFINED_28", + "AKGL_ACTOR_STATE_UNDEFINED_29", + "AKGL_ACTOR_STATE_UNDEFINED_30", + "AKGL_ACTOR_STATE_UNDEFINED_31", }; diff --git a/src/assets.c b/src/assets.c index 9097701..bc90c2b 100644 --- a/src/assets.c +++ b/src/assets.c @@ -7,19 +7,19 @@ #include #include -akerr_ErrorContext *load_start_bgm(char *fname) +akerr_ErrorContext *akgl_load_start_bgm(char *fname) { PREPARE_ERROR(errctx); - //string *tmpstr = NULL; + //akgl_String *tmpstr = NULL; MIX_Track *bgmtrack = NULL; SDL_PropertiesID bgmprops = 0; ATTEMPT { - FAIL_ZERO_BREAK(errctx, fname, AKERR_NULLPOINTER, "load_start_bgm received NULL filename"); - //CATCH(errctx, heap_next_string(&tmpstr)); - //CATCH(errctx, string_initialize(tmpstr, NULL)); + FAIL_ZERO_BREAK(errctx, fname, AKERR_NULLPOINTER, "akgl_load_start_bgm received NULL filename"); + //CATCH(errctx, akgl_heap_next_string(&tmpstr)); + //CATCH(errctx, akgl_string_initialize(tmpstr, NULL)); - //SDL_snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), fname); + //SDL_snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), fname); SDL_Log("Loading music asset from %s", fname); bgm = MIX_LoadAudio(game.mixer, fname, true); FAIL_ZERO_BREAK(errctx, bgm, AKERR_NULLPOINTER, "Failed to load music asset %s : %s", fname, SDL_GetError()); @@ -27,22 +27,22 @@ akerr_ErrorContext *load_start_bgm(char *fname) bgmtrack = MIX_CreateTrack(game.mixer); FAIL_ZERO_BREAK(errctx, bgmtrack, AKERR_NULLPOINTER, "Failed to create audio track for background music: %s", SDL_GetError()); - game.tracks[GAME_AUDIO_TRACK_BGM] = bgmtrack; + game.tracks[AKGL_GAME_AUDIO_TRACK_BGM] = bgmtrack; FAIL_ZERO_BREAK( errctx, MIX_SetTrackAudio(bgmtrack, bgm), - AKERR_SDL, + AKGL_ERR_SDL, "%s", SDL_GetError()); SDL_SetNumberProperty(bgmprops, MIX_PROP_PLAY_LOOPS_NUMBER, -1); if (!MIX_PlayTrack(bgmtrack, bgmprops)) { - FAIL_BREAK(errctx, AKERR_SDL, "Failed to play music asset %s", fname); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Failed to play music asset %s", fname); } } CLEANUP { - //IGNORE(heap_release_string(tmpstr)); + //IGNORE(akgl_heap_release_string(tmpstr)); if ( errctx != NULL ) { if ( errctx->status != 0 && bgm != NULL) { MIX_DestroyAudio(bgm); diff --git a/src/character.c b/src/character.c index 37e4252..ab12781 100644 --- a/src/character.c +++ b/src/character.c @@ -13,29 +13,29 @@ #include #include -akerr_ErrorContext *character_initialize(character *obj, char *name) +akerr_ErrorContext *akgl_character_initialize(akgl_Character *obj, char *name) { PREPARE_ERROR(errctx); - FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL character reference"); + FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL akgl_Character reference"); FAIL_ZERO_RETURN(errctx, name, AKERR_NULLPOINTER, "NULL name string pointer"); - memset(obj, 0x00, sizeof(character)); - strncpy(obj->name, name, SPRITE_MAX_CHARACTER_NAME_LENGTH); + memset(obj, 0x00, sizeof(akgl_Character)); + strncpy(obj->name, name, AKGL_SPRITE_MAX_CHARACTER_NAME_LENGTH); obj->state_sprites = SDL_CreateProperties(); FAIL_ZERO_RETURN(errctx, obj->state_sprites, AKERR_NULLPOINTER, "Unable to initialize SDL_PropertiesID for character state map"); - obj->sprite_add = &character_sprite_add; - obj->sprite_get = &character_sprite_get; + obj->sprite_add = &akgl_character_sprite_add; + obj->sprite_get = &akgl_character_sprite_get; FAIL_ZERO_RETURN( errctx, - SDL_SetPointerProperty(REGISTRY_CHARACTER, name, (void *)obj), + SDL_SetPointerProperty(AKGL_REGISTRY_CHARACTER, name, (void *)obj), AKERR_KEY, "Unable to add character to registry"); obj->refcount += 1; SUCCEED_RETURN(errctx); } -akerr_ErrorContext *character_sprite_add(character *basechar, sprite *ref, int state) +akerr_ErrorContext *akgl_character_sprite_add(akgl_Character *basechar, akgl_Sprite *ref, int state) { PREPARE_ERROR(errctx); char stateval[32]; @@ -49,16 +49,16 @@ akerr_ErrorContext *character_sprite_add(character *basechar, sprite *ref, int s SUCCEED_RETURN(errctx); } -akerr_ErrorContext *character_sprite_get(character *basechar, int state, sprite **dest) +akerr_ErrorContext *akgl_character_sprite_get(akgl_Character *basechar, int state, akgl_Sprite **dest) { - sprite *target = NULL; + akgl_Sprite *target = NULL; PREPARE_ERROR(errctx); char stateval[32]; FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "NULL pointer to sprite pointer (**dest)"); FAIL_ZERO_RETURN(errctx, basechar, AKERR_NULLPOINTER, "NULL character reference"); memset(&stateval, 0x00, 32); SDL_itoa(state, (char *)&stateval, 10); - *dest = (sprite *)SDL_GetPointerProperty(basechar->state_sprites, (char *)&stateval, NULL); + *dest = (akgl_Sprite *)SDL_GetPointerProperty(basechar->state_sprites, (char *)&stateval, NULL); FAIL_ZERO_RETURN(errctx, *dest, AKERR_KEY, "Sprite for state %d (%b) not found in the character's registry", state, state); target = *dest; //SDL_Log("Sprite state %d (%s) has character %s", state, (char *)&stateval, target->name); @@ -67,79 +67,79 @@ akerr_ErrorContext *character_sprite_get(character *basechar, int state, sprite // SDL iterator so we can't return error information here, void only // this means we don't have anywhere to send exceptions up to, so if we hit an error, we log and exit(1) here -void character_state_sprites_iterate(void *userdata, SDL_PropertiesID registry, const char *name) +void akgl_character_state_sprites_iterate(void *userdata, SDL_PropertiesID registry, const char *name) { PREPARE_ERROR(errctx); - sprite *spriteptr; - iterator *opflags = (iterator *)userdata; + akgl_Sprite *spriteptr; + akgl_Iterator *opflags = (akgl_Iterator *)userdata; ATTEMPT { FAIL_ZERO_BREAK(errctx, opflags, AKERR_NULLPOINTER, "Character state sprite iterator received null iterator op pointer"); FAIL_ZERO_BREAK(errctx, name, AKERR_NULLPOINTER, "Character state sprite iterator received null sprite name"); - spriteptr = (sprite *)SDL_GetPointerProperty(registry, name, NULL); + spriteptr = (akgl_Sprite *)SDL_GetPointerProperty(registry, name, NULL); FAIL_ZERO_BREAK(errctx, spriteptr, AKERR_NULLPOINTER, "Character state sprite for %s not found", name); - if ( BITMASK_HAS(opflags->flags, ITERATOR_OP_RELEASE) ) { - CATCH(errctx, heap_release_sprite(spriteptr)); + if ( AKGL_BITMASK_HAS(opflags->flags, AKGL_ITERATOR_OP_RELEASE) ) { + CATCH(errctx, akgl_heap_release_sprite(spriteptr)); } } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); } -static akerr_ErrorContext *character_load_json_state_int_from_strings(json_t *states, int *dest) +static akerr_ErrorContext *akgl_character_load_json_state_int_from_strings(json_t *states, int *dest) { int i = 0; long newstate = 0; - string *tmpstring = NULL; + akgl_String *tmpstring = NULL; PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, states, AKERR_NULLPOINTER, "NULL states array"); FAIL_ZERO_RETURN(errctx, states, AKERR_NULLPOINTER, "NULL destination integer"); ATTEMPT { - CATCH(errctx, heap_next_string(&tmpstring)); + CATCH(errctx, akgl_heap_next_string(&tmpstring)); for ( i = 0; i < json_array_size((json_t *)states) ; i++ ) { - CATCH(errctx, get_json_array_index_string(states, i, &tmpstring)); - newstate = (long)SDL_GetNumberProperty(REGISTRY_ACTOR_STATE_STRINGS, (char *)&tmpstring->data, 0); + CATCH(errctx, akgl_get_json_array_index_string(states, i, &tmpstring)); + newstate = (long)SDL_GetNumberProperty(AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS, (char *)&tmpstring->data, 0); FAIL_ZERO_BREAK(errctx, newstate, AKERR_KEY, "Unknown actor state %s", (char *)&tmpstring->data); *dest = (*dest | (int)(newstate)); } } CLEANUP { - IGNORE(heap_release_string(tmpstring)); + IGNORE(akgl_heap_release_string(tmpstring)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -static akerr_ErrorContext *character_load_json_inner(json_t *json, character *obj) +static akerr_ErrorContext *akgl_character_load_json_inner(json_t *json, akgl_Character *obj) { PREPARE_ERROR(errctx); json_t *mappings = NULL; json_t *curmapping = NULL; json_t *statearray = NULL; - sprite *spriteptr = NULL; + akgl_Sprite *spriteptr = NULL; int i = 0; - string *tmpstr = NULL; - string *tmpstr2 = NULL; + akgl_String *tmpstr = NULL; + akgl_String *tmpstr2 = NULL; int stateval = 0; ATTEMPT { - CATCH(errctx, get_json_string_value((json_t *)json, "name", &tmpstr)); - CATCH(errctx, character_initialize((character *)obj, tmpstr->data)); - CATCH(errctx, get_json_array_value((json_t *)json, "sprite_mappings", &mappings)); + CATCH(errctx, akgl_get_json_string_value((json_t *)json, "name", &tmpstr)); + CATCH(errctx, akgl_character_initialize((akgl_Character *)obj, tmpstr->data)); + CATCH(errctx, akgl_get_json_array_value((json_t *)json, "sprite_mappings", &mappings)); for ( i = 0; i < json_array_size((json_t *)mappings) ; i++ ) { stateval = 0; - CATCH(errctx, get_json_array_index_object((json_t *)mappings, i, &curmapping)); - CATCH(errctx, get_json_string_value((json_t *)curmapping, "sprite", &tmpstr)); - spriteptr = (sprite *)SDL_GetPointerProperty( - REGISTRY_SPRITE, + CATCH(errctx, akgl_get_json_array_index_object((json_t *)mappings, i, &curmapping)); + CATCH(errctx, akgl_get_json_string_value((json_t *)curmapping, "sprite", &tmpstr)); + spriteptr = (akgl_Sprite *)SDL_GetPointerProperty( + AKGL_REGISTRY_SPRITE, tmpstr->data, NULL ); - CATCH(errctx, get_json_string_value((json_t *)json, "name", &tmpstr2)); + CATCH(errctx, akgl_get_json_string_value((json_t *)json, "name", &tmpstr2)); - CATCH(errctx, get_json_array_value((json_t *)curmapping, "state", &statearray)); - CATCH(errctx, character_load_json_state_int_from_strings(statearray, &stateval)); + CATCH(errctx, akgl_get_json_array_value((json_t *)curmapping, "state", &statearray)); + CATCH(errctx, akgl_character_load_json_state_int_from_strings(statearray, &stateval)); - CATCH(errctx, get_json_string_value((json_t *)curmapping, "sprite", &tmpstr)); + CATCH(errctx, akgl_get_json_string_value((json_t *)curmapping, "sprite", &tmpstr)); FAIL_ZERO_BREAK( errctx, spriteptr, @@ -149,34 +149,34 @@ static akerr_ErrorContext *character_load_json_inner(json_t *json, character *ob stateval, tmpstr->data ); - CATCH(errctx, character_sprite_add((character *)obj, (sprite *)spriteptr, stateval)); + CATCH(errctx, akgl_character_sprite_add((akgl_Character *)obj, (akgl_Sprite *)spriteptr, stateval)); } } CLEANUP { if ( tmpstr != NULL ) { - IGNORE(heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_string(tmpstr)); } if ( tmpstr2 != NULL ) { - IGNORE(heap_release_string(tmpstr2)); + IGNORE(akgl_heap_release_string(tmpstr2)); } } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *character_load_json(char *filename) +akerr_ErrorContext *akgl_character_load_json(char *filename) { PREPARE_ERROR(errctx); json_t *json; json_error_t error; - character *obj = NULL; - //string *tmpstr = NULL; + akgl_Character *obj = NULL; + //akgl_String *tmpstr = NULL; FAIL_ZERO_RETURN(errctx, filename, AKERR_NULLPOINTER, "Received null filename"); ATTEMPT { - CATCH(errctx, heap_next_character(&obj)); - //CATCH(errctx, heap_next_string(&tmpstr)); - //CATCH(errctx, string_initialize(tmpstr, NULL)); - //SDL_snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), filename); + CATCH(errctx, akgl_heap_next_character(&obj)); + //CATCH(errctx, akgl_heap_next_string(&tmpstr)); + //CATCH(errctx, akgl_string_initialize(tmpstr, NULL)); + //SDL_snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), filename); json = (json_t *)json_load_file(filename, 0, &error); FAIL_ZERO_BREAK( errctx, @@ -184,16 +184,16 @@ akerr_ErrorContext *character_load_json(char *filename) AKERR_NULLPOINTER, "Error while loading character from %s on line %d: %s", filename, error.line, error.text ); - CATCH(errctx, character_load_json_inner(json, obj)); - CATCH(errctx, get_json_integer_value(json, "movementspeed", (int *)&obj->movementspeed)); - obj->movementspeed = obj->movementspeed * TIME_ONESEC_MS; - CATCH(errctx, get_json_number_value(json, "velocity_x", &obj->vx)); - CATCH(errctx, get_json_number_value(json, "velocity_y", &obj->vy)); + CATCH(errctx, akgl_character_load_json_inner(json, obj)); + CATCH(errctx, akgl_get_json_integer_value(json, "movementspeed", (int *)&obj->movementspeed)); + obj->movementspeed = obj->movementspeed * AKGL_TIME_ONESEC_MS; + CATCH(errctx, akgl_get_json_number_value(json, "velocity_x", &obj->vx)); + CATCH(errctx, akgl_get_json_number_value(json, "velocity_y", &obj->vy)); } CLEANUP { - //IGNORE(heap_release_string(tmpstr)); + //IGNORE(akgl_heap_release_string(tmpstr)); if ( errctx != NULL ) { if ( errctx->status != 0 ) { - IGNORE(heap_release_character(obj)); + IGNORE(akgl_heap_release_character(obj)); } } } PROCESS(errctx) { diff --git a/src/controller.c b/src/controller.c index 74b02d1..b40362a 100644 --- a/src/controller.c +++ b/src/controller.c @@ -5,26 +5,26 @@ #include #include -SDL3GControlMap GAME_ControlMaps[MAX_CONTROL_MAPS]; +akgl_ControlMap GAME_ControlMaps[AKGL_MAX_CONTROL_MAPS]; -akerr_ErrorContext *controller_handle_event(void *appstate, SDL_Event *event) +akerr_ErrorContext *akgl_controller_handle_event(void *appstate, SDL_Event *event) { int i = 0; int j = 0; int eventButtonComboMatch = 0; - SDL3GControlMap *curmap = NULL; - SDL3GControl *curcontrol = NULL; + akgl_ControlMap *curmap = NULL; + akgl_Control *curcontrol = NULL; PREPARE_ERROR(errctx); ATTEMPT { - for ( i = 0 ; i < MAX_CONTROL_MAPS; i++ ) { + for ( i = 0 ; i < AKGL_MAX_CONTROL_MAPS; i++ ) { curmap = &GAME_ControlMaps[i]; if ( curmap->target == NULL ) { continue; } //SDL_Log("Control map %d maps to actor %s", i, curmap->target->name); //SDL_Log("event from keyboard %d", event->key.which); - for ( j = 0; j < MAX_CONTROLS; j++ ) { + for ( j = 0; j < AKGL_MAX_CONTROLS; j++ ) { curcontrol = &curmap->controls[j]; //SDL_Log("button/key is processed by controlmap %d control %d", i, j); //SDL_Log("event %d -> control on %d off %d", event->type, curcontrol->event_on, curcontrol->event_off); @@ -41,14 +41,14 @@ akerr_ErrorContext *controller_handle_event(void *appstate, SDL_Event *event) ); if ( event->type == curcontrol->event_on && eventButtonComboMatch) { CATCH(errctx, curcontrol->handler_on(curmap->target, event)); - goto _controller_handle_event_success; + goto _akgl_controller_handle_event_success; } else if ( event->type == curcontrol->event_off && eventButtonComboMatch ) { CATCH(errctx, curcontrol->handler_off(curmap->target, event)); - goto _controller_handle_event_success; + goto _akgl_controller_handle_event_success; } } } -_controller_handle_event_success: +_akgl_controller_handle_event_success: } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); @@ -57,49 +57,49 @@ _controller_handle_event_success: akerr_ErrorContext *gamepad_handle_button_down(void *appstate, SDL_Event *event) { - actor *player = NULL; + akgl_Actor *player = NULL; PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, appstate, AKERR_NULLPOINTER, "NULL appstate"); FAIL_ZERO_RETURN(errctx, appstate, AKERR_NULLPOINTER, "NULL event"); - player = SDL_GetPointerProperty(REGISTRY_ACTOR, "player", NULL); + player = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "player", NULL); FAIL_ZERO_RETURN(errctx, appstate, AKERR_NULLPOINTER, "Player actor does not exist"); if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_DOWN || event->key.key == SDLK_DOWN ) { SDL_Log("Processing dpad down : state %d", player->state); - BITMASK_ADD(player->state, ACTOR_STATE_MOVING_DOWN); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_MOVING_DOWN); if ( !player->movement_controls_face ) { - BITMASK_DEL(player->state, ACTOR_STATE_FACE_ALL); - BITMASK_ADD(player->state, ACTOR_STATE_FACE_DOWN); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_FACE_ALL); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_FACE_DOWN); } SDL_Log("New state : %d", player->state); } else if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_UP || event->key.key == SDLK_UP ) { SDL_Log("Processing dpad up"); - BITMASK_ADD(player->state, ACTOR_STATE_MOVING_UP); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_MOVING_UP); if ( !player->movement_controls_face ) { - BITMASK_DEL(player->state, ACTOR_STATE_FACE_ALL); - BITMASK_ADD(player->state, ACTOR_STATE_FACE_UP); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_FACE_ALL); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_FACE_UP); } SDL_Log("New state : %d", player->state); } else if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_LEFT || event->key.key == SDLK_LEFT ) { SDL_Log("Processing dpad left"); - BITMASK_ADD(player->state, ACTOR_STATE_MOVING_LEFT); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_MOVING_LEFT); if ( !player->movement_controls_face ) { - BITMASK_DEL(player->state, ACTOR_STATE_FACE_ALL); - BITMASK_ADD(player->state, ACTOR_STATE_FACE_LEFT); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_FACE_ALL); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_FACE_LEFT); } SDL_Log("New state : %d", player->state); } else if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_RIGHT || event->key.key == SDLK_RIGHT ) { SDL_Log("Processing dpad right"); - BITMASK_ADD(player->state, ACTOR_STATE_MOVING_RIGHT); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_MOVING_RIGHT); if ( !player->movement_controls_face ) { - BITMASK_DEL(player->state, ACTOR_STATE_FACE_ALL); - BITMASK_ADD(player->state, ACTOR_STATE_FACE_RIGHT); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_FACE_ALL); + AKGL_BITMASK_ADD(player->state, AKGL_ACTOR_STATE_FACE_RIGHT); } SDL_Log("New state : %d", player->state); } @@ -108,37 +108,37 @@ akerr_ErrorContext *gamepad_handle_button_down(void *appstate, SDL_Event *event) akerr_ErrorContext *gamepad_handle_button_up(void *appstate, SDL_Event *event) { - actor *player = NULL; + akgl_Actor *player = NULL; PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, appstate, AKERR_NULLPOINTER, "NULL appstate"); FAIL_ZERO_RETURN(errctx, appstate, AKERR_NULLPOINTER, "NULL event"); - player = SDL_GetPointerProperty(REGISTRY_ACTOR, "player", NULL); + player = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "player", NULL); FAIL_ZERO_RETURN(errctx, appstate, AKERR_NULLPOINTER, "Player actor does not exist"); if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_DOWN || event->key.key == SDLK_DOWN ) { SDL_Log("processing down release"); - BITMASK_DEL(player->state, ACTOR_STATE_MOVING_DOWN); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_MOVING_DOWN); player->curSpriteFrameId = 0; SDL_Log("New state : %d", player->state); } else if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_UP || event->key.key == SDLK_UP ) { SDL_Log("processing up release"); - BITMASK_DEL(player->state, ACTOR_STATE_MOVING_UP); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_MOVING_UP); player->curSpriteFrameId = 0; SDL_Log("New state : %d", player->state); } else if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_RIGHT || event->key.key == SDLK_RIGHT) { SDL_Log("processing right release"); - BITMASK_DEL(player->state, ACTOR_STATE_MOVING_RIGHT); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_MOVING_RIGHT); player->curSpriteFrameId = 0; SDL_Log("New state : %d", player->state); } else if ( event->gbutton.button == SDL_GAMEPAD_BUTTON_DPAD_LEFT || event->key.key == SDLK_LEFT ) { SDL_Log("processing left release"); - BITMASK_DEL(player->state, ACTOR_STATE_MOVING_LEFT); + AKGL_BITMASK_DEL(player->state, AKGL_ACTOR_STATE_MOVING_LEFT); player->curSpriteFrameId = 0; SDL_Log("New state : %d", player->state); } @@ -194,16 +194,16 @@ akerr_ErrorContext *gamepad_handle_removed(void *appstate, SDL_Event *event) SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_pushmap(int controlmapid, SDL3GControl *control) +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_pushmap(int controlmapid, akgl_Control *control) { int newmapid = 0; PREPARE_ERROR(errctx); ATTEMPT { FAIL_ZERO_RETURN(errctx, control, AKERR_NULLPOINTER, "NULL Control"); - FAIL_NONZERO_RETURN(errctx, (controlmapid >= MAX_CONTROL_MAPS), AKERR_OUTOFBOUNDS, "ID %d exceeds maximum %d", controlmapid, MAX_CONTROL_MAPS); + FAIL_NONZERO_RETURN(errctx, (controlmapid >= AKGL_MAX_CONTROL_MAPS), AKERR_OUTOFBOUNDS, "ID %d exceeds maximum %d", controlmapid, AKGL_MAX_CONTROL_MAPS); newmapid = GAME_ControlMaps[controlmapid].nextMap; - FAIL_ZERO_RETURN(errctx, (MAX_CONTROLS - newmapid), AKERR_OUTOFBOUNDS, "Control map ID %d is full", controlmapid); - memcpy((void *)&GAME_ControlMaps[controlmapid].controls[newmapid], control, sizeof(SDL3GControl)); + FAIL_ZERO_RETURN(errctx, (AKGL_MAX_CONTROLS - newmapid), AKERR_OUTOFBOUNDS, "Control map ID %d is full", controlmapid); + memcpy((void *)&GAME_ControlMaps[controlmapid].controls[newmapid], control, sizeof(akgl_Control)); GAME_ControlMaps[controlmapid].nextMap = newmapid + 1; } CLEANUP { } PROCESS(errctx) { @@ -211,21 +211,21 @@ akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_pushmap(int controlmapid, SD SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_default(int controlmapid, char *actorname, int kbid, int jsid) +akerr_ErrorContext AKERR_NOIGNORE *akgl_controller_default(int controlmapid, char *actorname, int kbid, int jsid) { - SDL3GControlMap *controlmap; - SDL3GControl control; + akgl_ControlMap *controlmap; + akgl_Control control; PREPARE_ERROR(errctx); ATTEMPT { // set up the control map - FAIL_NONZERO_RETURN(errctx, (controlmapid >= MAX_CONTROL_MAPS), AKERR_OUTOFBOUNDS, "ID %d exceeds maximum %d", controlmapid, MAX_CONTROL_MAPS); - memset((void *)&control, 0x00, sizeof(SDL3GControl)); + FAIL_NONZERO_RETURN(errctx, (controlmapid >= AKGL_MAX_CONTROL_MAPS), AKERR_OUTOFBOUNDS, "ID %d exceeds maximum %d", controlmapid, AKGL_MAX_CONTROL_MAPS); + memset((void *)&control, 0x00, sizeof(akgl_Control)); controlmap = &GAME_ControlMaps[controlmapid]; controlmap->kbid = kbid; controlmap->jsid = jsid; - controlmap->target = SDL_GetPointerProperty(REGISTRY_ACTOR, actorname, NULL); + controlmap->target = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, actorname, NULL); FAIL_ZERO_BREAK(errctx, controlmap->target, AKERR_REGISTRY, "Actor %s not found in registry", actorname); // ---- KEYBOARD CONTROLS ---- @@ -234,33 +234,33 @@ akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_default(int controlmapid, ch control.key = SDLK_DOWN; control.event_on = SDL_EVENT_KEY_DOWN; control.event_off = SDL_EVENT_KEY_UP; - control.handler_on = &SDL3GActor_cmhf_down_on; - control.handler_off = &SDL3GActor_cmhf_down_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_down_on; + control.handler_off = &akgl_Actor_cmhf_down_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); // Move up control.key = SDLK_UP; control.event_on = SDL_EVENT_KEY_DOWN; control.event_off = SDL_EVENT_KEY_UP; - control.handler_on = &SDL3GActor_cmhf_up_on; - control.handler_off = &SDL3GActor_cmhf_up_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_up_on; + control.handler_off = &akgl_Actor_cmhf_up_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); // Move left control.key = SDLK_LEFT; control.event_on = SDL_EVENT_KEY_DOWN; control.event_off = SDL_EVENT_KEY_UP; - control.handler_on = &SDL3GActor_cmhf_left_on; - control.handler_off = &SDL3GActor_cmhf_left_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_left_on; + control.handler_off = &akgl_Actor_cmhf_left_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); // Move right control.key = SDLK_RIGHT; control.event_on = SDL_EVENT_KEY_DOWN; control.event_off = SDL_EVENT_KEY_UP; - control.handler_on = &SDL3GActor_cmhf_right_on; - control.handler_off = &SDL3GActor_cmhf_right_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_right_on; + control.handler_off = &akgl_Actor_cmhf_right_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); control.key = 0; // ----- GAMEPAD CONTROLS @@ -268,33 +268,33 @@ akerr_ErrorContext AKERR_NOIGNORE *SDL3G_controller_default(int controlmapid, ch control.button = SDL_GAMEPAD_BUTTON_DPAD_DOWN; control.event_on = SDL_EVENT_GAMEPAD_BUTTON_DOWN; control.event_off = SDL_EVENT_GAMEPAD_BUTTON_UP; - control.handler_on = &SDL3GActor_cmhf_down_on; - control.handler_off = &SDL3GActor_cmhf_down_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_down_on; + control.handler_off = &akgl_Actor_cmhf_down_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); // Move up control.button = SDL_GAMEPAD_BUTTON_DPAD_UP; control.event_on = SDL_EVENT_GAMEPAD_BUTTON_DOWN; control.event_off = SDL_EVENT_GAMEPAD_BUTTON_UP; - control.handler_on = &SDL3GActor_cmhf_up_on; - control.handler_off = &SDL3GActor_cmhf_up_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_up_on; + control.handler_off = &akgl_Actor_cmhf_up_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); // Move left control.button = SDL_GAMEPAD_BUTTON_DPAD_LEFT; control.event_on = SDL_EVENT_GAMEPAD_BUTTON_DOWN; control.event_off = SDL_EVENT_GAMEPAD_BUTTON_UP; - control.handler_on = &SDL3GActor_cmhf_left_on; - control.handler_off = &SDL3GActor_cmhf_left_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_left_on; + control.handler_off = &akgl_Actor_cmhf_left_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); // Move right control.button = SDL_GAMEPAD_BUTTON_DPAD_RIGHT; control.event_on = SDL_EVENT_GAMEPAD_BUTTON_DOWN; control.event_off = SDL_EVENT_GAMEPAD_BUTTON_UP; - control.handler_on = &SDL3GActor_cmhf_right_on; - control.handler_off = &SDL3GActor_cmhf_right_off; - CATCH(errctx, SDL3G_controller_pushmap(controlmapid, &control)); + control.handler_on = &akgl_Actor_cmhf_right_on; + control.handler_off = &akgl_Actor_cmhf_right_off; + CATCH(errctx, akgl_controller_pushmap(controlmapid, &control)); SUCCEED_RETURN(errctx); diff --git a/src/draw.c b/src/draw.c index 2f59ee6..1380644 100644 --- a/src/draw.c +++ b/src/draw.c @@ -4,7 +4,7 @@ #include /* Draw a Gimpish background pattern to show transparency in the image */ -void GAME_draw_background(int w, int h) +void akgl_draw_background(int w, int h) { SDL_Color col[2] = { { 0x66, 0x66, 0x66, 0xff }, diff --git a/src/game.c b/src/game.c index f06fe00..053c0ea 100644 --- a/src/game.c +++ b/src/game.c @@ -17,18 +17,18 @@ SDL_Window *window = NULL; SDL_Renderer *renderer = NULL; -GAME_frame ball; -GAME_frame paddle1; -GAME_frame paddle2; -GAME_frame table; -tilemap gamemap; +akgl_Frame ball; +akgl_Frame paddle1; +akgl_Frame paddle2; +akgl_Frame table; +akgl_Tilemap gamemap; MIX_Audio *bgm = NULL; MIX_Mixer *GAME_mixer = NULL; MIX_Track *GAME_tracks[64]; SDL_FRect camera; -Game game; +akgl_Game game; -akerr_ErrorContext AKERR_NOIGNORE *GAME_init() +akerr_ErrorContext AKERR_NOIGNORE *akgl_game_init() { int i = 0; PREPARE_ERROR(errctx); @@ -39,64 +39,64 @@ akerr_ErrorContext AKERR_NOIGNORE *GAME_init() FAIL_ZERO_BREAK(errctx, strlen((char *)&game.name), AKERR_NULLPOINTER, "Must provide game name"); FAIL_ZERO_BREAK(errctx, strlen((char *)&game.version), AKERR_NULLPOINTER, "Must provide game version"); FAIL_ZERO_BREAK(errctx, strlen((char *)&game.uri), AKERR_NULLPOINTER, "Must provide game uri"); - CATCH(errctx, heap_init()); - CATCH(errctx, registry_init_actor()); - CATCH(errctx, registry_init_sprite()); - CATCH(errctx, registry_init_spritesheet()); - CATCH(errctx, registry_init_character()); - CATCH(errctx, registry_init_font()); - CATCH(errctx, registry_init_music()); - CATCH(errctx, registry_init_actor_state_strings()); + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_registry_init_actor()); + CATCH(errctx, akgl_registry_init_sprite()); + CATCH(errctx, akgl_registry_init_spritesheet()); + CATCH(errctx, akgl_registry_init_character()); + CATCH(errctx, akgl_registry_init_font()); + CATCH(errctx, akgl_registry_init_music()); + CATCH(errctx, akgl_registry_init_actor_state_strings()); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true) SDL_SetAppMetadata(game.name, game.version, game.uri); - for ( i = 0 ; i < MAX_CONTROL_MAPS; i++ ) { - memset(&GAME_ControlMaps[i], 0x00, sizeof(SDL3GControlMap)); + for ( i = 0 ; i < AKGL_MAX_CONTROL_MAPS; i++ ) { + memset(&GAME_ControlMaps[i], 0x00, sizeof(akgl_ControlMap)); } FAIL_ZERO_RETURN( errctx, SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD | SDL_INIT_AUDIO), - AKERR_SDL, + AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); // Load the Game Controller DB - for ( i = 0; i < SDL_GAMECONTROLLER_DB_LEN ; i++ ) { + for ( i = 0; i < AKGL_SDL_GAMECONTROLLER_DB_LEN ; i++ ) { if ( SDL_AddGamepadMapping(SDL_GAMECONTROLLER_DB[i]) == -1 ) { - FAIL_ZERO_RETURN(errctx, 0, AKERR_SDL, "%s", SDL_GetError()); + FAIL_ZERO_RETURN(errctx, 0, AKGL_ERR_SDL, "%s", SDL_GetError()); } } FAIL_ZERO_RETURN( errctx, SDL_CreateWindowAndRenderer(game.uri, game.screenwidth, game.screenheight, 0, &window, &renderer), - AKERR_SDL, + AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); FAIL_ZERO_RETURN( errctx, MIX_Init(), - AKERR_SDL, + AKGL_ERR_SDL, "Couldn't initialize audio: %s", SDL_GetError()); game.mixer = MIX_CreateMixerDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, 0); FAIL_ZERO_RETURN( errctx, game.mixer, - AKERR_SDL, + AKGL_ERR_SDL, "Unable to create mixer device: %s", SDL_GetError()); FAIL_ZERO_RETURN( errctx, TTF_Init(), - AKERR_SDL, + AKGL_ERR_SDL, "Couldn't initialize front engine: %s", SDL_GetError()); @@ -106,11 +106,11 @@ akerr_ErrorContext AKERR_NOIGNORE *GAME_init() camera.h = game.screenheight; } -void GAME_updateFPS() +void akgl_game_updateFPS() { SDL_Time curTime; curTime = SDL_GetTicksNS(); - if ( (curTime - game.lastFPSTime) > TIME_ONESEC_NS ) { + if ( (curTime - game.lastFPSTime) > AKGL_TIME_ONESEC_NS ) { game.fps = game.framesSinceUpdate; game.framesSinceUpdate = 0; game.lastFPSTime = curTime; diff --git a/src/heap.c b/src/heap.c index fbea55b..6aa9646 100644 --- a/src/heap.c +++ b/src/heap.c @@ -9,39 +9,39 @@ #include #include -actor HEAP_ACTOR[MAX_HEAP_ACTOR]; -sprite HEAP_SPRITE[MAX_HEAP_SPRITE]; -spritesheet HEAP_SPRITESHEET[MAX_HEAP_SPRITESHEET]; -character HEAP_CHARACTER[MAX_HEAP_CHARACTER]; -string HEAP_STRING[MAX_HEAP_STRING]; +akgl_Actor HEAP_ACTOR[AKGL_MAX_HEAP_ACTOR]; +akgl_Sprite HEAP_SPRITE[AKGL_MAX_HEAP_SPRITE]; +akgl_SpriteSheet HEAP_SPRITESHEET[AKGL_MAX_HEAP_SPRITESHEET]; +akgl_Character HEAP_CHARACTER[AKGL_MAX_HEAP_CHARACTER]; +akgl_String HEAP_STRING[AKGL_MAX_HEAP_STRING]; -akerr_ErrorContext *heap_init() +akerr_ErrorContext *akgl_heap_init() { PREPARE_ERROR(errctx); int i = 0; - akerr_name_for_status(AKERR_SDL, "SDL Error"); - for ( i = 0; i < MAX_HEAP_ACTOR; i++) { - memset(&HEAP_ACTOR[i], 0x00, sizeof(actor)); + akerr_name_for_status(AKGL_ERR_SDL, "SDL Error"); + for ( i = 0; i < AKGL_MAX_HEAP_ACTOR; i++) { + memset(&HEAP_ACTOR[i], 0x00, sizeof(akgl_Actor)); } - for ( i = 0; i < MAX_HEAP_SPRITE; i++) { - memset(&HEAP_SPRITE[i], 0x00, sizeof(sprite)); + for ( i = 0; i < AKGL_MAX_HEAP_SPRITE; i++) { + memset(&HEAP_SPRITE[i], 0x00, sizeof(akgl_Sprite)); } - for ( i = 0; i < MAX_HEAP_SPRITESHEET; i++) { - memset(&HEAP_SPRITESHEET[i], 0x00, sizeof(spritesheet)); + for ( i = 0; i < AKGL_MAX_HEAP_SPRITESHEET; i++) { + memset(&HEAP_SPRITESHEET[i], 0x00, sizeof(akgl_SpriteSheet)); } - for ( i = 0; i < MAX_HEAP_CHARACTER; i++) { - memset(&HEAP_CHARACTER[i], 0x00, sizeof(character)); + for ( i = 0; i < AKGL_MAX_HEAP_CHARACTER; i++) { + memset(&HEAP_CHARACTER[i], 0x00, sizeof(akgl_Character)); } - for ( i = 0; i < MAX_HEAP_STRING; i++) { - memset(&HEAP_STRING[i], 0x00, sizeof(string)); + for ( i = 0; i < AKGL_MAX_HEAP_STRING; i++) { + memset(&HEAP_STRING[i], 0x00, sizeof(akgl_String)); } SUCCEED_RETURN(errctx); } -akerr_ErrorContext *heap_next_actor(actor **dest) +akerr_ErrorContext *akgl_heap_next_actor(akgl_Actor **dest) { PREPARE_ERROR(errctx); - for (int i = 0; i < MAX_HEAP_ACTOR; i++ ) { + for (int i = 0; i < AKGL_MAX_HEAP_ACTOR; i++ ) { if ( HEAP_ACTOR[i].refcount != 0 ) { continue; } @@ -51,10 +51,10 @@ akerr_ErrorContext *heap_next_actor(actor **dest) FAIL_RETURN(errctx, AKERR_HEAP, "Unable to find unused actor on the heap"); } -akerr_ErrorContext *heap_next_sprite(sprite **dest) +akerr_ErrorContext *akgl_heap_next_sprite(akgl_Sprite **dest) { PREPARE_ERROR(errctx); - for (int i = 0; i < MAX_HEAP_SPRITE; i++ ) { + for (int i = 0; i < AKGL_MAX_HEAP_SPRITE; i++ ) { if ( HEAP_SPRITE[i].refcount != 0 ) { continue; } @@ -64,10 +64,10 @@ akerr_ErrorContext *heap_next_sprite(sprite **dest) FAIL_RETURN(errctx, AKERR_HEAP, "Unable to find unused sprite on the heap"); } -akerr_ErrorContext *heap_next_spritesheet(spritesheet **dest) +akerr_ErrorContext *akgl_heap_next_spritesheet(akgl_SpriteSheet **dest) { PREPARE_ERROR(errctx); - for (int i = 0; i < MAX_HEAP_SPRITESHEET; i++ ) { + for (int i = 0; i < AKGL_MAX_HEAP_SPRITESHEET; i++ ) { if ( HEAP_SPRITESHEET[i].refcount != 0 ) { continue; } @@ -77,10 +77,10 @@ akerr_ErrorContext *heap_next_spritesheet(spritesheet **dest) FAIL_RETURN(errctx, AKERR_HEAP, "Unable to find unused spritesheet on the heap"); } -akerr_ErrorContext *heap_next_character(character **dest) +akerr_ErrorContext *akgl_heap_next_character(akgl_Character **dest) { PREPARE_ERROR(errctx); - for (int i = 0; i < MAX_HEAP_CHARACTER; i++ ) { + for (int i = 0; i < AKGL_MAX_HEAP_CHARACTER; i++ ) { if ( HEAP_CHARACTER[i].refcount != 0 ) { continue; } @@ -90,10 +90,10 @@ akerr_ErrorContext *heap_next_character(character **dest) FAIL_RETURN(errctx, AKERR_HEAP, "Unable to find unused character on the heap"); } -akerr_ErrorContext *heap_next_string(string **dest) +akerr_ErrorContext *akgl_heap_next_string(akgl_String **dest) { PREPARE_ERROR(errctx); - for (int i = 0; i < MAX_HEAP_STRING; i++ ) { + for (int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) { if ( HEAP_STRING[i].refcount != 0 ) { continue; } @@ -103,7 +103,7 @@ akerr_ErrorContext *heap_next_string(string **dest) FAIL_RETURN(errctx, AKERR_HEAP, "Unable to find unused string on the heap"); } -akerr_ErrorContext *heap_release_actor(actor *ptr) +akerr_ErrorContext *akgl_heap_release_actor(akgl_Actor *ptr) { int i = 0; PREPARE_ERROR(errctx); @@ -112,39 +112,39 @@ akerr_ErrorContext *heap_release_actor(actor *ptr) ptr->refcount -= 1; } if ( ptr->refcount == 0 ) { - for ( i = 0; i < ACTOR_MAX_CHILDREN; i++ ) { + for ( i = 0; i < AKGL_ACTOR_MAX_CHILDREN; i++ ) { if ( ptr->children[i] != NULL ) { - CATCH_AND_RETURN(errctx, heap_release_actor(ptr->children[i])); + CATCH_AND_RETURN(errctx, akgl_heap_release_actor(ptr->children[i])); } } if ( ptr->basechar != NULL ) { - CATCH_AND_RETURN(errctx, heap_release_character(ptr->basechar)); + CATCH_AND_RETURN(errctx, akgl_heap_release_character(ptr->basechar)); } - memset(ptr, 0x00, sizeof(actor)); - SDL_ClearProperty(REGISTRY_ACTOR, (char *)&ptr->name); + memset(ptr, 0x00, sizeof(akgl_Actor)); + SDL_ClearProperty(AKGL_REGISTRY_ACTOR, (char *)&ptr->name); } SUCCEED_RETURN(errctx); } -akerr_ErrorContext *heap_release_character(character *basechar) +akerr_ErrorContext *akgl_heap_release_character(akgl_Character *basechar) { PREPARE_ERROR(errctx); - iterator opflags; + akgl_Iterator opflags; FAIL_ZERO_RETURN(errctx, basechar, AKERR_NULLPOINTER, "NULL character reference"); - BITMASK_CLEAR(opflags.flags); - BITMASK_ADD(opflags.flags, ITERATOR_OP_RELEASE); + AKGL_BITMASK_CLEAR(opflags.flags); + AKGL_BITMASK_ADD(opflags.flags, AKGL_ITERATOR_OP_RELEASE); if ( basechar->refcount > 0 ) { basechar->refcount -= 1; } if ( basechar->refcount == 0 ) { - SDL_EnumerateProperties(basechar->state_sprites, &character_state_sprites_iterate, (void *)&opflags); - SDL_ClearProperty(REGISTRY_CHARACTER, (char *)&basechar->name); + SDL_EnumerateProperties(basechar->state_sprites, &akgl_character_state_sprites_iterate, (void *)&opflags); + SDL_ClearProperty(AKGL_REGISTRY_CHARACTER, (char *)&basechar->name); } SUCCEED_RETURN(errctx); } -akerr_ErrorContext *heap_release_sprite(sprite *ptr) +akerr_ErrorContext *akgl_heap_release_sprite(akgl_Sprite *ptr) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, ptr, AKERR_NULLPOINTER, "Received NULL sprite reference"); @@ -153,16 +153,16 @@ akerr_ErrorContext *heap_release_sprite(sprite *ptr) } if ( ptr->refcount == 0 ) { ATTEMPT { - CATCH(errctx, heap_release_spritesheet(ptr->sheet)); + CATCH(errctx, akgl_heap_release_spritesheet(ptr->sheet)); } CLEANUP { - SDL_ClearProperty(REGISTRY_SPRITE, (char *)&ptr->name); + SDL_ClearProperty(AKGL_REGISTRY_SPRITE, (char *)&ptr->name); } PROCESS(errctx) { } FINISH(errctx, true); } SUCCEED_RETURN(errctx); } -akerr_ErrorContext *heap_release_spritesheet(spritesheet *ptr) +akerr_ErrorContext *akgl_heap_release_spritesheet(akgl_SpriteSheet *ptr) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, ptr, AKERR_NULLPOINTER, "Received NULL spritesheet reference"); @@ -171,7 +171,7 @@ akerr_ErrorContext *heap_release_spritesheet(spritesheet *ptr) } if ( ptr->refcount == 0 ) { // TODO : If we go threaded, make sure this is only happening on the main thread - SDL_ClearProperty(REGISTRY_SPRITESHEET, (char *)&ptr->name); + SDL_ClearProperty(AKGL_AKGL_REGISTRY_SPRITESHEET, (char *)&ptr->name); if ( ptr-> texture != NULL ) SDL_DestroyTexture(ptr->texture); ptr->texture = NULL; @@ -179,7 +179,7 @@ akerr_ErrorContext *heap_release_spritesheet(spritesheet *ptr) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *heap_release_string(string *ptr) +akerr_ErrorContext *akgl_heap_release_string(akgl_String *ptr) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, ptr, AKERR_NULLPOINTER, "Received NULL string reference"); @@ -187,7 +187,7 @@ akerr_ErrorContext *heap_release_string(string *ptr) ptr->refcount -= 1; } if ( ptr->refcount == 0 ) { - memset(&ptr->data, 0x00, MAX_STRING_LENGTH); + memset(&ptr->data, 0x00, AKGL_MAX_STRING_LENGTH); } SUCCEED_RETURN(errctx); } diff --git a/src/json_helpers.c b/src/json_helpers.c index 10baf18..0ad5b7a 100644 --- a/src/json_helpers.c +++ b/src/json_helpers.c @@ -8,7 +8,7 @@ #include #include -akerr_ErrorContext *get_json_object_value(json_t *obj, char *key, json_t **dest) +akerr_ErrorContext *akgl_get_json_object_value(json_t *obj, char *key, json_t **dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL object pointer"); @@ -19,7 +19,7 @@ akerr_ErrorContext *get_json_object_value(json_t *obj, char *key, json_t **dest) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_boolean_value(json_t *obj, char *key, bool *dest) +akerr_ErrorContext *akgl_get_json_boolean_value(json_t *obj, char *key, bool *dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL object pointer"); @@ -30,7 +30,7 @@ akerr_ErrorContext *get_json_boolean_value(json_t *obj, char *key, bool *dest) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_integer_value(json_t *obj, char *key, int *dest) +akerr_ErrorContext *akgl_get_json_integer_value(json_t *obj, char *key, int *dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL object pointer"); @@ -41,7 +41,7 @@ akerr_ErrorContext *get_json_integer_value(json_t *obj, char *key, int *dest) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_number_value(json_t *obj, char *key, float *dest) +akerr_ErrorContext *akgl_get_json_number_value(json_t *obj, char *key, float *dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL pointer reference"); @@ -52,7 +52,7 @@ akerr_ErrorContext *get_json_number_value(json_t *obj, char *key, float *dest) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_string_value(json_t *obj, char *key, string **dest) +akerr_ErrorContext *akgl_get_json_string_value(json_t *obj, char *key, akgl_String **dest) { json_t *value = NULL; PREPARE_ERROR(errctx); @@ -65,18 +65,18 @@ akerr_ErrorContext *get_json_string_value(json_t *obj, char *key, string **dest) FAIL_ZERO_RETURN(errctx, (json_is_string(value)), AKERR_TYPE, "Key %s in object has incorrect type", key); ATTEMPT { if ( *dest == NULL ) { - CATCH(errctx, heap_next_string(dest)); - CATCH(errctx, string_initialize(*dest, NULL)); + CATCH(errctx, akgl_heap_next_string(dest)); + CATCH(errctx, akgl_string_initialize(*dest, NULL)); } } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, false); - strncpy((char *)&(*dest)->data, json_string_value(value), MAX_STRING_LENGTH); + strncpy((char *)&(*dest)->data, json_string_value(value), AKGL_MAX_STRING_LENGTH); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_array_value(json_t *obj, char *key, json_t **dest) +akerr_ErrorContext *akgl_get_json_array_value(json_t *obj, char *key, json_t **dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "NULL pointer reference"); @@ -87,7 +87,7 @@ akerr_ErrorContext *get_json_array_value(json_t *obj, char *key, json_t **dest) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_array_index_object(json_t *array, int index, json_t **dest) +akerr_ErrorContext *akgl_get_json_array_index_object(json_t *array, int index, json_t **dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, array, AKERR_NULLPOINTER, "NULL pointer reference"); @@ -98,7 +98,7 @@ akerr_ErrorContext *get_json_array_index_object(json_t *array, int index, json_t SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_array_index_integer(json_t *array, int index, int *dest) +akerr_ErrorContext *akgl_get_json_array_index_integer(json_t *array, int index, int *dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, array, AKERR_NULLPOINTER, "NULL pointer reference"); @@ -109,7 +109,7 @@ akerr_ErrorContext *get_json_array_index_integer(json_t *array, int index, int * SUCCEED_RETURN(errctx); } -akerr_ErrorContext *get_json_array_index_string(json_t *array, int index, string **dest) +akerr_ErrorContext *akgl_get_json_array_index_string(json_t *array, int index, akgl_String **dest) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, array, AKERR_NULLPOINTER, "NULL pointer reference"); @@ -119,13 +119,13 @@ akerr_ErrorContext *get_json_array_index_string(json_t *array, int index, string FAIL_ZERO_RETURN(errctx, (json_is_string(value)), AKERR_TYPE, "Index %d in object has incorrect type", index); ATTEMPT { if ( *dest == NULL ) { - CATCH(errctx, heap_next_string(dest)); - CATCH(errctx, string_initialize(*dest, NULL)); + CATCH(errctx, akgl_heap_next_string(dest)); + CATCH(errctx, akgl_string_initialize(*dest, NULL)); } } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, false); - strncpy((char *)&(*dest)->data, json_string_value(value), MAX_STRING_LENGTH); + strncpy((char *)&(*dest)->data, json_string_value(value), AKGL_MAX_STRING_LENGTH); SUCCEED_RETURN(errctx); } diff --git a/src/registry.c b/src/registry.c index e7d5156..799ebdf 100644 --- a/src/registry.c +++ b/src/registry.c @@ -6,92 +6,92 @@ #include #include -SDL_PropertiesID REGISTRY_ACTOR; -SDL_PropertiesID REGISTRY_ACTOR_STATE_STRINGS; -SDL_PropertiesID REGISTRY_SPRITE; -SDL_PropertiesID REGISTRY_SPRITESHEET; -SDL_PropertiesID REGISTRY_CHARACTER; -SDL_PropertiesID REGISTRY_MUSIC; -SDL_PropertiesID REGISTRY_FONT; +SDL_PropertiesID AKGL_REGISTRY_ACTOR; +SDL_PropertiesID AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS; +SDL_PropertiesID AKGL_REGISTRY_SPRITE; +SDL_PropertiesID AKGL_AKGL_REGISTRY_SPRITESHEET; +SDL_PropertiesID AKGL_REGISTRY_CHARACTER; +SDL_PropertiesID AKGL_REGISTRY_MUSIC; +SDL_PropertiesID AKGL_REGISTRY_FONT; -akerr_ErrorContext *registry_init() +akerr_ErrorContext *akgl_registry_init() { PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, registry_init_spritesheet()); - CATCH(errctx, registry_init_sprite()); - CATCH(errctx, registry_init_character()); - CATCH(errctx, registry_init_actor()); - CATCH(errctx, registry_init_actor_state_strings()); - CATCH(errctx, registry_init_font()); - CATCH(errctx, registry_init_music()); + CATCH(errctx, akgl_registry_init_spritesheet()); + CATCH(errctx, akgl_registry_init_sprite()); + CATCH(errctx, akgl_registry_init_character()); + CATCH(errctx, akgl_registry_init_actor()); + CATCH(errctx, akgl_registry_init_actor_state_strings()); + CATCH(errctx, akgl_registry_init_font()); + CATCH(errctx, akgl_registry_init_music()); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *registry_init_actor() +akerr_ErrorContext *akgl_registry_init_actor() { PREPARE_ERROR(errctx); - REGISTRY_ACTOR = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_ACTOR, AKERR_NULLPOINTER, "Error initializing actor registry"); + AKGL_REGISTRY_ACTOR = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_REGISTRY_ACTOR, AKERR_NULLPOINTER, "Error initializing actor registry"); SUCCEED_RETURN(errctx); } -akerr_ErrorContext AKERR_NOIGNORE *registry_init_font() +akerr_ErrorContext AKERR_NOIGNORE *akgl_registry_init_font() { PREPARE_ERROR(errctx); - REGISTRY_FONT = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_FONT, AKERR_NULLPOINTER, "Error initializing font registry"); + AKGL_REGISTRY_FONT = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_REGISTRY_FONT, AKERR_NULLPOINTER, "Error initializing font registry"); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *registry_init_music() +akerr_ErrorContext *akgl_registry_init_music() { PREPARE_ERROR(errctx); - REGISTRY_MUSIC = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_MUSIC, AKERR_NULLPOINTER, "Error initializing music registry"); + AKGL_REGISTRY_MUSIC = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_REGISTRY_MUSIC, AKERR_NULLPOINTER, "Error initializing music registry"); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *registry_init_actor_state_strings() +akerr_ErrorContext *akgl_registry_init_actor_state_strings() { int i = 0; int flag = 0; PREPARE_ERROR(errctx); - REGISTRY_ACTOR_STATE_STRINGS = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_ACTOR_STATE_STRINGS, AKERR_NULLPOINTER, "Error initializing actor state strings registry"); - for ( i = 0 ; i < ACTOR_MAX_STATES; i++ ) { + AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS, AKERR_NULLPOINTER, "Error initializing actor state strings registry"); + for ( i = 0 ; i < AKGL_ACTOR_MAX_STATES; i++ ) { flag = (1 << i); SDL_SetNumberProperty( - REGISTRY_ACTOR_STATE_STRINGS, - ACTOR_STATE_STRING_NAMES[i], + AKGL_AKGL_REGISTRY_ACTOR_STATE_STRINGS, + AKGL_ACTOR_STATE_STRING_NAMES[i], flag); } SUCCEED_RETURN(errctx); } -akerr_ErrorContext *registry_init_sprite() +akerr_ErrorContext *akgl_registry_init_sprite() { PREPARE_ERROR(errctx); - REGISTRY_SPRITE = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_SPRITE, AKERR_NULLPOINTER, "Error initializing sprite registry"); + AKGL_REGISTRY_SPRITE = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_REGISTRY_SPRITE, AKERR_NULLPOINTER, "Error initializing sprite registry"); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *registry_init_spritesheet() +akerr_ErrorContext *akgl_registry_init_spritesheet() { PREPARE_ERROR(errctx); - REGISTRY_SPRITESHEET = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_SPRITESHEET, AKERR_NULLPOINTER, "Error initializing spritesheet registry"); + AKGL_AKGL_REGISTRY_SPRITESHEET = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_AKGL_REGISTRY_SPRITESHEET, AKERR_NULLPOINTER, "Error initializing spritesheet registry"); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *registry_init_character() +akerr_ErrorContext *akgl_registry_init_character() { PREPARE_ERROR(errctx); - REGISTRY_CHARACTER = SDL_CreateProperties(); - FAIL_ZERO_RETURN(errctx, REGISTRY_CHARACTER, AKERR_NULLPOINTER, "Error initializing character registry"); + AKGL_REGISTRY_CHARACTER = SDL_CreateProperties(); + FAIL_ZERO_RETURN(errctx, AKGL_REGISTRY_CHARACTER, AKERR_NULLPOINTER, "Error initializing character registry"); SUCCEED_RETURN(errctx); } diff --git a/src/sprite.c b/src/sprite.c index 87ff67e..4e27685 100644 --- a/src/sprite.c +++ b/src/sprite.c @@ -13,72 +13,72 @@ #include #include -static akerr_ErrorContext *sprite_load_json_spritesheet(json_t *json, spritesheet **sheet, char *relative_path) +static akerr_ErrorContext *akgl_sprite_load_json_spritesheet(json_t *json, akgl_SpriteSheet **sheet, char *relative_path) { PREPARE_ERROR(errctx); json_t *spritesheet_json = NULL; int ss_frame_width = 0; int ss_frame_height = 0; - string *ss_filename = NULL; - string *tmpstr = NULL; + akgl_String *ss_filename = NULL; + akgl_String *tmpstr = NULL; ATTEMPT { - CATCH(errctx, heap_next_string(&tmpstr)); - CATCH(errctx, string_initialize(tmpstr, NULL)); - CATCH(errctx, get_json_object_value((json_t *)json, "spritesheet", &spritesheet_json)); - CATCH(errctx, get_json_string_value((json_t *)spritesheet_json, "filename", &ss_filename)); + CATCH(errctx, akgl_heap_next_string(&tmpstr)); + CATCH(errctx, akgl_string_initialize(tmpstr, NULL)); + CATCH(errctx, akgl_get_json_object_value((json_t *)json, "spritesheet", &spritesheet_json)); + CATCH(errctx, akgl_get_json_string_value((json_t *)spritesheet_json, "filename", &ss_filename)); if ( ss_filename->data[0] != '/' ) { - SDL_snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s/%s", relative_path, ss_filename->data); + SDL_snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s/%s", relative_path, ss_filename->data); } else { - SDL_snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s", ss_filename->data); + SDL_snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s", ss_filename->data); } *sheet = SDL_GetPointerProperty( - REGISTRY_SPRITESHEET, + AKGL_AKGL_REGISTRY_SPRITESHEET, (char *)&tmpstr->data, NULL ); if ( *sheet == NULL ) { - CATCH(errctx, heap_next_spritesheet(sheet)); - CATCH(errctx, get_json_integer_value((json_t *)spritesheet_json, "frame_width", &ss_frame_width)); - CATCH(errctx, get_json_integer_value((json_t *)spritesheet_json, "frame_height", &ss_frame_width)); + CATCH(errctx, akgl_heap_next_spritesheet(sheet)); + CATCH(errctx, akgl_get_json_integer_value((json_t *)spritesheet_json, "frame_width", &ss_frame_width)); + CATCH(errctx, akgl_get_json_integer_value((json_t *)spritesheet_json, "frame_height", &ss_frame_width)); CATCH(errctx, - spritesheet_initialize( - (spritesheet *)*sheet, + akgl_spritesheet_initialize( + (akgl_SpriteSheet *)*sheet, ss_frame_width, ss_frame_height, (char *)&tmpstr->data) ); } } CLEANUP { - IGNORE(heap_release_string(ss_filename)); - IGNORE(heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_string(ss_filename)); + IGNORE(akgl_heap_release_string(tmpstr)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *sprite_load_json(char *filename) +akerr_ErrorContext *akgl_sprite_load_json(char *filename) { PREPARE_ERROR(errctx); json_t *json = NULL; json_t *frames = NULL; json_error_t error; - sprite *obj = NULL; - spritesheet *sheet = NULL; - string *spritename = NULL; + akgl_Sprite *obj = NULL; + akgl_SpriteSheet *sheet = NULL; + akgl_String *spritename = NULL; //string *tmpstr = NULL; int i = 0; FAIL_ZERO_RETURN(errctx, filename, AKERR_NULLPOINTER, "Received null filename"); ATTEMPT { - CATCH(errctx, heap_next_sprite(&obj)); - //CATCH(errctx, heap_next_string(&tmpstr)); - //CATCH(errctx, string_initialize(tmpstr, NULL)); - CATCH(errctx, heap_next_string(&spritename)); - CATCH(errctx, string_initialize(spritename, NULL)); + CATCH(errctx, akgl_heap_next_sprite(&obj)); + //CATCH(errctx, akgl_heap_next_string(&tmpstr)); + //CATCH(errctx, akgl_string_initialize(tmpstr, NULL)); + CATCH(errctx, akgl_heap_next_string(&spritename)); + CATCH(errctx, akgl_string_initialize(spritename, NULL)); - //SDL_snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), filename); + //SDL_snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), filename); json = (json_t *)json_load_file(filename, 0, &error); FAIL_ZERO_BREAK( errctx, @@ -87,87 +87,87 @@ akerr_ErrorContext *sprite_load_json(char *filename) "Error while loading sprite from %s on line %d: %s", filename, error.line, error.text ); - CATCH(errctx, sprite_load_json_spritesheet((json_t *)json, &sheet, dirname(filename))); - CATCH(errctx, get_json_string_value((json_t *)json, "name", &spritename)); + CATCH(errctx, akgl_sprite_load_json_spritesheet((json_t *)json, &sheet, dirname(filename))); + CATCH(errctx, akgl_get_json_string_value((json_t *)json, "name", &spritename)); CATCH(errctx, - sprite_initialize( - (sprite *)obj, + akgl_sprite_initialize( + (akgl_Sprite *)obj, spritename->data, - (spritesheet *)sheet) + (akgl_SpriteSheet *)sheet) ); - CATCH(errctx, get_json_integer_value((json_t *)json, "width", &obj->width)); - CATCH(errctx, get_json_integer_value((json_t *)json, "height", &obj->height)); - CATCH(errctx, get_json_integer_value((json_t *)json, "speed", (int *)&obj->speed)); - obj->speed = obj->speed * TIME_ONESEC_MS; - CATCH(errctx, get_json_boolean_value((json_t *)json, "loop", &obj->loop)); - CATCH(errctx, get_json_boolean_value((json_t *)json, "loopReverse", &obj->loopReverse)); + 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)); + 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)); - CATCH(errctx, get_json_array_value((json_t *)json, "frames", &frames)); + 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, get_json_array_index_integer((json_t *)frames, i, &obj->frameids[i])); + CATCH(errctx, akgl_get_json_array_index_integer((json_t *)frames, i, &obj->frameids[i])); } } CLEANUP { if ( errctx != NULL && errctx->status != 0 ) { - IGNORE(heap_release_sprite(obj)); - IGNORE(heap_release_spritesheet(sheet)); + IGNORE(akgl_heap_release_sprite(obj)); + IGNORE(akgl_heap_release_spritesheet(sheet)); } - IGNORE(heap_release_string(spritename)); - //IGNORE(heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_string(spritename)); + //IGNORE(akgl_heap_release_string(tmpstr)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *sprite_initialize(sprite *spr, char *name, spritesheet *sheet) +akerr_ErrorContext *akgl_sprite_initialize(akgl_Sprite *spr, char *name, akgl_SpriteSheet *sheet) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, spr, AKERR_NULLPOINTER, "Null sprite reference"); FAIL_ZERO_RETURN(errctx, name, AKERR_NULLPOINTER, "Empty sprite name"); FAIL_ZERO_RETURN(errctx, sheet, AKERR_NULLPOINTER, "Null spritesheet reference"); - memset(spr, 0x00, sizeof(sprite)); - memcpy(spr->name, name, SPRITE_MAX_NAME_LENGTH); + memset(spr, 0x00, sizeof(akgl_Sprite)); + memcpy(spr->name, name, AKGL_SPRITE_MAX_NAME_LENGTH); spr->sheet = sheet; FAIL_ZERO_RETURN( errctx, - SDL_SetPointerProperty(REGISTRY_SPRITE, (char *)&spr->name, (void *)spr), + SDL_SetPointerProperty(AKGL_REGISTRY_SPRITE, (char *)&spr->name, (void *)spr), AKERR_KEY, "Unable to add sprite to registry"); spr->refcount += 1; SUCCEED_RETURN(errctx); } -akerr_ErrorContext *spritesheet_initialize(spritesheet *sheet, int sprite_w, int sprite_h, char *filename) +akerr_ErrorContext *akgl_spritesheet_initialize(akgl_SpriteSheet *sheet, int sprite_w, int sprite_h, char *filename) { PREPARE_ERROR(errctx); - //string *tmpstr = NULL; + //akgl_String *tmpstr = NULL; ATTEMPT { FAIL_ZERO_BREAK(errctx, sheet, AKERR_NULLPOINTER, "Null spritesheet pointer"); FAIL_ZERO_BREAK(errctx, filename, AKERR_NULLPOINTER, "Null filename pointer"); - memset(sheet, 0x00, sizeof(spritesheet)); + memset(sheet, 0x00, sizeof(akgl_SpriteSheet)); - //CATCH(errctx, heap_next_string(&tmpstr)); + //CATCH(errctx, akgl_heap_next_string(&tmpstr)); - //CATCH(errctx, string_initialize(tmpstr, NULL)); - strncpy((char *)&sheet->name, filename, SPRITE_SHEET_MAX_FILENAME_LENGTH); + //CATCH(errctx, akgl_string_initialize(tmpstr, NULL)); + strncpy((char *)&sheet->name, filename, AKGL_SPRITE_SHEET_MAX_FILENAME_LENGTH); - //snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), filename); + //snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), filename); sheet->texture = IMG_LoadTexture(renderer, filename); - FAIL_ZERO_BREAK(errctx, sheet->texture, AKERR_SDL, "Failed loading asset %s : %s", filename, SDL_GetError()); + FAIL_ZERO_BREAK(errctx, sheet->texture, AKGL_ERR_SDL, "Failed loading asset %s : %s", filename, SDL_GetError()); FAIL_ZERO_BREAK( errctx, - SDL_SetPointerProperty(REGISTRY_SPRITESHEET, (char *)sheet->name, (void *)sheet), + SDL_SetPointerProperty(AKGL_AKGL_REGISTRY_SPRITESHEET, (char *)sheet->name, (void *)sheet), AKERR_KEY, "Unable to add spritesheet to registry: %s", SDL_GetError()); sheet->refcount += 1; } CLEANUP { - //IGNORE(heap_release_string(tmpstr)); + //IGNORE(akgl_heap_release_string(tmpstr)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); diff --git a/src/staticstring.c b/src/staticstring.c index 08dadcb..fe2017b 100644 --- a/src/staticstring.c +++ b/src/staticstring.c @@ -1,14 +1,14 @@ #include #include -akerr_ErrorContext *string_initialize(string *obj, char *init) +akerr_ErrorContext *akgl_string_initialize(akgl_String *obj, char *init) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, obj, AKERR_NULLPOINTER, "Attempted to initialize NULL string reference"); if ( init != NULL ) { - strncpy((char *)&obj->data, init, MAX_STRING_LENGTH); + strncpy((char *)&obj->data, init, AKGL_MAX_STRING_LENGTH); } else { - memset(&obj->data, 0x00, sizeof(string)); + memset(&obj->data, 0x00, sizeof(akgl_String)); } obj->refcount = 1; SUCCEED_RETURN(errctx); diff --git a/src/text.c b/src/text.c new file mode 100644 index 0000000..2e9e8aa --- /dev/null +++ b/src/text.c @@ -0,0 +1,60 @@ +#include +#include +#include +#include +#include +#include + +akerr_ErrorContext AKERR_NOIGNORE *akgl_text_loadfont(char *name, char *filepath, int size) +{ + TTF_Font *font = NULL; + + PREPARE_ERROR(errctx); + FAIL_ZERO_RETURN(errctx, name, AKERR_NULLPOINTER, "Null font name"); + FAIL_ZERO_RETURN(errctx, name, AKERR_NULLPOINTER, "Null filepath"); + font = TTF_OpenFont(filepath, size); + FAIL_ZERO_RETURN(errctx, font, AKGL_ERR_SDL, "%s", SDL_GetError()); + FAIL_ZERO_RETURN( + errctx, + SDL_SetPointerProperty(AKGL_REGISTRY_FONT, name, (void *)font), + AKERR_KEY, + "Unable to add font %p to registry as %s : %s", + (void *)font, + name, + SDL_GetError()); + SUCCEED_RETURN(errctx); +} + +akerr_ErrorContext AKERR_NOIGNORE *akgl_text_rendertextat(TTF_Font *font, char *text, SDL_Color color, int wraplength, int x, int y) +{ + SDL_Surface *textsurf = NULL; + SDL_Texture *texture = NULL; + SDL_FRect dest; + + PREPARE_ERROR(errctx); + FAIL_ZERO_RETURN(errctx, font, AKERR_NULLPOINTER, "NULL font"); + FAIL_ZERO_RETURN(errctx, text, AKERR_NULLPOINTER, "NULL text string"); + if ( wraplength > 0 ) { + textsurf = TTF_RenderText_Blended_Wrapped( + font, + text, + 0, + color, + wraplength); + } else { + textsurf = TTF_RenderText_Blended( + font, + text, + 0, + color); + } + FAIL_ZERO_RETURN(errctx, textsurf, AKERR_NULLPOINTER, "%s", SDL_GetError()); + texture = SDL_CreateTextureFromSurface(renderer, textsurf); + FAIL_ZERO_RETURN(errctx, texture, AKERR_NULLPOINTER, "%s", SDL_GetError()); + dest.x = x; + dest.y = y; + SDL_GetTextureSize(texture, &dest.w, &dest.h); + FAIL_ZERO_RETURN(errctx, SDL_RenderTexture(renderer, texture, NULL, &dest), AKERR_NULLPOINTER, "%s", SDL_GetError()); + SDL_DestroyTexture(texture); + SUCCEED_RETURN(errctx); +} diff --git a/src/tilemap.c b/src/tilemap.c index 564d403..00644e5 100644 --- a/src/tilemap.c +++ b/src/tilemap.c @@ -13,27 +13,27 @@ #include #include -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 diff --git a/src/util.c b/src/util.c index 8dc0932..7183999 100644 --- a/src/util.c +++ b/src/util.c @@ -10,7 +10,7 @@ #include #include -akerr_ErrorContext *rectangle_points(RectanglePoints *dest, SDL_FRect *rect) +akerr_ErrorContext *akgl_rectangle_points(RectanglePoints *dest, SDL_FRect *rect) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, dest, AKERR_NULLPOINTER, "NULL RectanglePoints reference"); @@ -26,7 +26,7 @@ akerr_ErrorContext *rectangle_points(RectanglePoints *dest, SDL_FRect *rect) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *collide_point_rectangle(point *p, RectanglePoints *rp, bool *collide) +akerr_ErrorContext *akgl_collide_point_rectangle(point *p, RectanglePoints *rp, bool *collide) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, p, AKERR_NULLPOINTER, "NULL Point reference"); @@ -41,7 +41,7 @@ akerr_ErrorContext *collide_point_rectangle(point *p, RectanglePoints *rp, bool SUCCEED_RETURN(errctx); } -akerr_ErrorContext *collide_rectangles(SDL_FRect *r1, SDL_FRect *r2, bool *collide) +akerr_ErrorContext *akgl_collide_rectangles(SDL_FRect *r1, SDL_FRect *r2, bool *collide) { RectanglePoints r1p; RectanglePoints r2p; @@ -51,39 +51,39 @@ akerr_ErrorContext *collide_rectangles(SDL_FRect *r1, SDL_FRect *r2, bool *colli FAIL_ZERO_RETURN(errctx, collide, AKERR_NULLPOINTER, "NULL collision flag reference"); ATTEMPT { - CATCH(errctx, rectangle_points(&r1p, r1)); - CATCH(errctx, rectangle_points(&r2p, r2)); + CATCH(errctx, akgl_rectangle_points(&r1p, r1)); + CATCH(errctx, akgl_rectangle_points(&r2p, r2)); // is the upper left corner of r1 contacting r2? - CATCH(errctx, collide_point_rectangle(&r1p.topleft, &r2p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r1p.topleft, &r2p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the upper left corner of r2 contacting r1? - CATCH(errctx, collide_point_rectangle(&r2p.topleft, &r1p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r2p.topleft, &r1p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the top right corner of r1 contacting r2? - CATCH(errctx, collide_point_rectangle(&r1p.topright, &r2p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r1p.topright, &r2p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the top right corner of r2 contacting r1? - CATCH(errctx, collide_point_rectangle(&r2p.topright, &r1p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r2p.topright, &r1p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the bottom left corner of r1 contacting r2? - CATCH(errctx, collide_point_rectangle(&r1p.bottomleft, &r2p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r1p.bottomleft, &r2p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the bottom left corner of r2 contacting r1? - CATCH(errctx, collide_point_rectangle(&r2p.bottomleft, &r1p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r2p.bottomleft, &r1p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the bottom right corner of r1 contacting r2? - CATCH(errctx, collide_point_rectangle(&r1p.bottomright, &r2p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r1p.bottomright, &r2p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } // is the bottom right corner of r2 contacting r1? - CATCH(errctx, collide_point_rectangle(&r2p.bottomright, &r1p, collide)); + CATCH(errctx, akgl_collide_point_rectangle(&r2p.bottomright, &r1p, collide)); if ( *collide == true ) { SUCCEED_RETURN(errctx); } } CLEANUP { @@ -95,7 +95,7 @@ akerr_ErrorContext *collide_rectangles(SDL_FRect *r1, SDL_FRect *r2, bool *colli } -akerr_ErrorContext *compare_sdl_surfaces(SDL_Surface *s1, SDL_Surface *s2) +akerr_ErrorContext *akgl_compare_sdl_surfaces(SDL_Surface *s1, SDL_Surface *s2) { PREPARE_ERROR(errctx); FAIL_ZERO_RETURN(errctx, s1, AKERR_NULLPOINTER, "NULL Surface pointer"); @@ -104,21 +104,21 @@ akerr_ErrorContext *compare_sdl_surfaces(SDL_Surface *s1, SDL_Surface *s2) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *render_and_compare(SDL_Texture *t1, SDL_Texture *t2, int x, int y, int w, int h, char *writeout) +akerr_ErrorContext *akgl_render_and_compare(SDL_Texture *t1, SDL_Texture *t2, int x, int y, int w, int h, char *writeout) { SDL_Surface *s1 = NULL; SDL_Surface *s2 = NULL; SDL_FRect src = {.x = x, .y = y, .w = w, .h = h}; SDL_FRect dest = {.x = x, .y = y, .w = w, .h = h}; SDL_Rect read = {.x = x, .y = y, .w = w, .h = h}; - string *tmpstring = NULL; + akgl_String *tmpstring = NULL; PREPARE_ERROR(errctx); ATTEMPT { FAIL_ZERO_BREAK(errctx, t1, AKERR_NULLPOINTER, "NULL texture"); FAIL_ZERO_BREAK(errctx, t2, AKERR_NULLPOINTER, "NULL texture"); - CATCH(errctx, heap_next_string(&tmpstring)); + CATCH(errctx, akgl_heap_next_string(&tmpstring)); SDL_RenderClear(renderer); FAIL_ZERO_BREAK( errctx, @@ -127,13 +127,13 @@ akerr_ErrorContext *render_and_compare(SDL_Texture *t1, SDL_Texture *t2, int x, t1, &src, &dest), - AKERR_SDL, + AKGL_ERR_SDL, "Failed to render test texture"); s1 = SDL_RenderReadPixels(renderer, &read); - FAIL_ZERO_BREAK(errctx, s1, AKERR_SDL, "Failed to read pixels from renderer"); + FAIL_ZERO_BREAK(errctx, s1, AKGL_ERR_SDL, "Failed to read pixels from renderer"); if ( writeout != NULL ) { - snprintf((char *)&tmpstring->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), writeout); + snprintf((char *)&tmpstring->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), writeout); FAIL_ZERO_BREAK( errctx, IMG_SavePNG(s1, (char *)&tmpstring->data), @@ -152,18 +152,18 @@ akerr_ErrorContext *render_and_compare(SDL_Texture *t1, SDL_Texture *t2, int x, t2, &src, &dest), - AKERR_SDL, + AKGL_ERR_SDL, "Failed to render test texture"); s2 = SDL_RenderReadPixels(renderer, &read); - FAIL_ZERO_BREAK(errctx, s2, AKERR_SDL, "Failed to read pixels from renderer"); + FAIL_ZERO_BREAK(errctx, s2, AKGL_ERR_SDL, "Failed to read pixels from renderer"); - CATCH(errctx, compare_sdl_surfaces(s1, s2)); + CATCH(errctx, akgl_compare_sdl_surfaces(s1, s2)); } CLEANUP { if ( s1 != NULL ) SDL_DestroySurface(s1); if ( s2 != NULL ) SDL_DestroySurface(s2); - IGNORE(heap_release_string(tmpstring)); + IGNORE(akgl_heap_release_string(tmpstring)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); diff --git a/tests/actor.c b/tests/actor.c index bbfaa35..fa135fd 100644 --- a/tests/actor.c +++ b/tests/actor.c @@ -32,20 +32,20 @@ void handle_unhandled_error_noexit(akerr_ErrorContext *errctx) } } -int actor_updated; -akerr_ErrorContext *actor_update_noop(actor *obj) +int akgl_actor_updated; +akerr_ErrorContext *akgl_actor_update_noop(akgl_Actor *obj) { PREPARE_ERROR(errctx); - actor_updated = 1; + akgl_actor_updated = 1; SUCCEED_RETURN(errctx); } // Currently the renderer assumes there is a global variable named `renderer` -int actor_rendered; -akerr_ErrorContext *actor_render_noop(actor *obj, SDL_Renderer *r) +int akgl_actor_rendered; +akerr_ErrorContext *akgl_actor_render_noop(akgl_Actor *obj, SDL_Renderer *r) { PREPARE_ERROR(errctx); - actor_rendered = 1; + akgl_actor_rendered = 1; SUCCEED_RETURN(errctx); } @@ -58,7 +58,7 @@ akerr_ErrorContext *test_registry_actor_iterator_nullpointers(void) akerr_handler_unhandled_error = handle_unhandled_error_noexit; ATTEMPT { UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_SET; - DETECT(unhandled_error_context, registry_iterate_actor(NULL, REGISTRY_ACTOR, "")); + DETECT(unhandled_error_context, akgl_registry_iterate_actor(NULL, AKGL_REGISTRY_ACTOR, "")); } CLEANUP { UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_EXIT; } PROCESS(unhandled_error_context) { @@ -74,7 +74,7 @@ akerr_ErrorContext *test_registry_actor_iterator_missingactor(void) PREPARE_ERROR(errctx); akerr_ErrorUnhandledErrorHandler defaulthandler = akerr_handler_unhandled_error; - iterator iter = { + akgl_Iterator iter = { .layerid = 0, .flags = 0 }; @@ -83,9 +83,9 @@ akerr_ErrorContext *test_registry_actor_iterator_missingactor(void) UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_SET; DETECT( unhandled_error_context, - registry_iterate_actor( + akgl_registry_iterate_actor( &iter, - REGISTRY_ACTOR, + AKGL_REGISTRY_ACTOR, "Actor who doesn't exist") ); } CLEANUP { @@ -100,10 +100,10 @@ akerr_ErrorContext *test_registry_actor_iterator_missingactor(void) akerr_ErrorContext *test_registry_actor_iterator_updaterender(void) { - actor *testactor; - iterator iter = { + akgl_Actor *testactor; + akgl_Iterator iter = { .layerid = 0, - .flags = ITERATOR_OP_UPDATE | ITERATOR_OP_RENDER + .flags = AKGL_ITERATOR_OP_UPDATE | AKGL_ITERATOR_OP_RENDER }; akerr_ErrorUnhandledErrorHandler defaulthandler = akerr_handler_unhandled_error; @@ -111,36 +111,36 @@ akerr_ErrorContext *test_registry_actor_iterator_updaterender(void) akerr_handler_unhandled_error = handle_unhandled_error_noexit; ATTEMPT { UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_SET; - CATCH(unhandled_error_context, heap_next_actor(&testactor)); - CATCH(unhandled_error_context, actor_initialize(testactor, "test")); + CATCH(unhandled_error_context, akgl_heap_next_actor(&testactor)); + CATCH(unhandled_error_context, akgl_actor_initialize(testactor, "test")); testactor->layer = 0; - testactor->updatefunc = &actor_update_noop; - testactor->renderfunc = &actor_render_noop; + testactor->updatefunc = &akgl_actor_update_noop; + testactor->renderfunc = &akgl_actor_render_noop; DETECT( unhandled_error_context, - registry_iterate_actor( + akgl_registry_iterate_actor( &iter, - REGISTRY_ACTOR, + AKGL_REGISTRY_ACTOR, "test") ); FAIL_ZERO_BREAK( unhandled_error_context, - actor_updated, + akgl_actor_updated, AKERR_BEHAVIOR, "actor->updatefunc not called by the iterator" ); FAIL_ZERO_BREAK( unhandled_error_context, - actor_rendered, + akgl_actor_rendered, AKERR_BEHAVIOR, "actor->renderfunc not called by the iterator" ); } CLEANUP { UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_EXIT; - IGNORE(heap_release_actor(testactor)); + IGNORE(akgl_heap_release_actor(testactor)); } PROCESS(unhandled_error_context) { } FINISH(unhandled_error_context, true); @@ -149,15 +149,15 @@ akerr_ErrorContext *test_registry_actor_iterator_updaterender(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_actor_set_character(void) +akerr_ErrorContext *test_akgl_actor_set_character(void) { - actor *testactor = NULL; - character *testchar = NULL; + akgl_Actor *testactor = NULL; + akgl_Character *testchar = NULL; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, actor_set_character(NULL, "test")); + CATCH(errctx, akgl_actor_set_character(NULL, "test")); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -166,36 +166,36 @@ akerr_ErrorContext *test_actor_set_character(void) ATTEMPT { - CATCH(errctx, heap_next_actor(&testactor)); + CATCH(errctx, akgl_heap_next_actor(&testactor)); - CATCH(errctx, actor_initialize(testactor, "test")); + CATCH(errctx, akgl_actor_initialize(testactor, "test")); testactor->layer = 0; - testactor->updatefunc = &actor_update_noop; - testactor->renderfunc = &actor_render_noop; + testactor->updatefunc = &akgl_actor_update_noop; + testactor->renderfunc = &akgl_actor_render_noop; - CATCH(errctx, actor_set_character(testactor, "test")); + CATCH(errctx, akgl_actor_set_character(testactor, "test")); } CLEANUP { - IGNORE(heap_release_actor(testactor)); + IGNORE(akgl_heap_release_actor(testactor)); } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { printf("Handled\n"); } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, heap_next_actor(&testactor)); - CATCH(errctx, heap_next_character(&testchar)); + CATCH(errctx, akgl_heap_next_actor(&testactor)); + CATCH(errctx, akgl_heap_next_character(&testchar)); - CATCH(errctx, actor_initialize(testactor, "test")); + CATCH(errctx, akgl_actor_initialize(testactor, "test")); testactor->layer = 0; - testactor->updatefunc = &actor_update_noop; - testactor->renderfunc = &actor_render_noop; + testactor->updatefunc = &akgl_actor_update_noop; + testactor->renderfunc = &akgl_actor_render_noop; - CATCH(errctx, character_initialize(testchar, "test")); + CATCH(errctx, akgl_character_initialize(testchar, "test")); - CATCH(errctx, actor_set_character(testactor, "test")); + CATCH(errctx, akgl_actor_set_character(testactor, "test")); } CLEANUP { - IGNORE(heap_release_actor(testactor)); - IGNORE(heap_release_character(testchar)); + IGNORE(akgl_heap_release_actor(testactor)); + IGNORE(akgl_heap_release_character(testchar)); } PROCESS(errctx) { } FINISH(errctx, true); @@ -204,28 +204,28 @@ akerr_ErrorContext *test_actor_set_character(void) akerr_ErrorContext *test_actor_manage_children(void) { - actor *parent = NULL; - actor *child = NULL; - string *tmpstring = NULL; + akgl_Actor *parent = NULL; + akgl_Actor *child = NULL; + akgl_String *tmpstring = NULL; int i = 0; int j = 0; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, heap_init()); - CATCH(errctx, heap_next_string(&tmpstring)); - CATCH(errctx, heap_next_actor(&parent)); - CATCH(errctx, actor_initialize(parent, "parent")); - for ( i = 0 ; i < ACTOR_MAX_CHILDREN; i++ ) { + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_heap_next_string(&tmpstring)); + CATCH(errctx, akgl_heap_next_actor(&parent)); + CATCH(errctx, akgl_actor_initialize(parent, "parent")); + for ( i = 0 ; i < AKGL_ACTOR_MAX_CHILDREN; i++ ) { sprintf((char *)&tmpstring->data, "child %d", i); - CATCH(errctx, heap_next_actor(&child)); - CATCH(errctx, actor_initialize(child, (char *)&tmpstring->data)); + CATCH(errctx, akgl_heap_next_actor(&child)); + CATCH(errctx, akgl_actor_initialize(child, (char *)&tmpstring->data)); CATCH(errctx, parent->addchild(parent, child)); // Release our claim on the actor so the parent can own the child and kill it - CATCH(errctx, heap_release_actor(child)); + CATCH(errctx, akgl_heap_release_actor(child)); } } CLEANUP { - IGNORE(heap_release_string(tmpstring)); + IGNORE(akgl_heap_release_string(tmpstring)); } PROCESS(errctx) { } FINISH(errctx, true); @@ -244,7 +244,7 @@ akerr_ErrorContext *test_actor_manage_children(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, heap_next_actor(&child)); + CATCH(errctx, akgl_heap_next_actor(&child)); CATCH(errctx, parent->addchild(parent, child)); } CLEANUP { if ( errctx == NULL ) { @@ -257,23 +257,23 @@ akerr_ErrorContext *test_actor_manage_children(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, heap_release_actor(parent)); + CATCH(errctx, akgl_heap_release_actor(parent)); // All actor objects on the heap should be empty now - for ( i = 0; i < MAX_HEAP_ACTOR; i++) { + for ( i = 0; i < AKGL_MAX_HEAP_ACTOR; i++) { FAIL_NONZERO_BREAK(errctx, HEAP_ACTOR[i].refcount, AKERR_VALUE, "Actor not properly cleared"); FAIL_NONZERO_BREAK(errctx, HEAP_ACTOR[i].parent, AKERR_VALUE, "Actor not properly cleared"); - for ( j = 0 ; j < ACTOR_MAX_CHILDREN; j++) { + for ( j = 0 ; j < AKGL_ACTOR_MAX_CHILDREN; j++) { if ( HEAP_ACTOR[i].children[j] != NULL ) { FAIL(errctx, AKERR_VALUE, "Actor not properly cleared"); goto _test_actor_addchild_heaprelease_cleanup; } } } - for ( j = 0; j < ACTOR_MAX_CHILDREN; j++) { + for ( j = 0; j < AKGL_ACTOR_MAX_CHILDREN; j++) { sprintf((char *)&tmpstring->data, "child %d", i); FAIL_NONZERO_BREAK( errctx, - SDL_GetPointerProperty(REGISTRY_ACTOR, (char *)&tmpstring->data, NULL), + SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, (char *)&tmpstring->data, NULL), AKERR_KEY, "Child %s was not removed from the registry", (char *)&tmpstring->data); @@ -284,22 +284,22 @@ _test_actor_addchild_heaprelease_cleanup: } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, heap_next_actor(&parent)); - CATCH(errctx, actor_initialize(parent, "parent")); - CATCH(errctx, heap_next_actor(&child)); - CATCH(errctx, actor_initialize(child, "child")); + CATCH(errctx, akgl_heap_next_actor(&parent)); + CATCH(errctx, akgl_actor_initialize(parent, "parent")); + CATCH(errctx, akgl_heap_next_actor(&child)); + CATCH(errctx, akgl_actor_initialize(child, "child")); // Don't release our claim on the child. The child should not be reclaimed. - CATCH(errctx, heap_release_actor(parent)); + CATCH(errctx, akgl_heap_release_actor(parent)); FAIL_NONZERO_BREAK(errctx, child->parent, AKERR_VALUE, "Child still references released parent"); FAIL_ZERO_BREAK(errctx, child->refcount, AKERR_VALUE, "Child prematurely released"); FAIL_NONZERO_BREAK(errctx, strcmp(child->name, "child"), AKERR_VALUE, "Child had identity erased"); FAIL_ZERO_BREAK( errctx, - (child == SDL_GetPointerProperty(REGISTRY_ACTOR, child->name, NULL)), + (child == SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, child->name, NULL)), AKERR_KEY, "Child prematurely removed from the registry"); // Now we can release the child - CATCH(errctx, heap_release_actor(child)); + CATCH(errctx, akgl_heap_release_actor(child)); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); @@ -309,20 +309,20 @@ _test_actor_addchild_heaprelease_cleanup: int main(void) { - actor_updated = 0; - actor_rendered = 0; + akgl_actor_updated = 0; + akgl_actor_rendered = 0; UNHANDLED_ERROR_BEHAVIOR = UNHANDLED_ERROR_EXIT; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, registry_init_actor()); - CATCH(errctx, registry_init_sprite()); - CATCH(errctx, registry_init_spritesheet()); - CATCH(errctx, registry_init_character()); + CATCH(errctx, akgl_registry_init_actor()); + CATCH(errctx, akgl_registry_init_sprite()); + CATCH(errctx, akgl_registry_init_spritesheet()); + CATCH(errctx, akgl_registry_init_character()); CATCH(errctx, test_registry_actor_iterator_nullpointers()); CATCH(errctx, test_registry_actor_iterator_missingactor()); CATCH(errctx, test_registry_actor_iterator_updaterender()); - CATCH(errctx, test_actor_set_character()); + CATCH(errctx, test_akgl_actor_set_character()); CATCH(errctx, test_actor_manage_children()); } CLEANUP { } PROCESS(errctx) { diff --git a/tests/assets/testcharacter.json b/tests/assets/testcharacter.json index 13308a4..975d3d6 100644 --- a/tests/assets/testcharacter.json +++ b/tests/assets/testcharacter.json @@ -5,8 +5,8 @@ "sprite_mappings": [ { "state": [ - "ACTOR_STATE_ALIVE", - "ACTOR_STATE_FACE_LEFT" + "AKGL_ACTOR_STATE_ALIVE", + "AKGL_ACTOR_STATE_FACE_LEFT" ], "sprite": "testsprite" }, diff --git a/tests/bitmasks.c b/tests/bitmasks.c index 3d759ef..ad127da 100644 --- a/tests/bitmasks.c +++ b/tests/bitmasks.c @@ -4,28 +4,28 @@ int main(void) { int mask = 0; - BITMASK_ADD(mask, ACTOR_STATE_ALIVE); - if ( mask != ACTOR_STATE_ALIVE ) + AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_ALIVE); + if ( mask != AKGL_ACTOR_STATE_ALIVE ) return 1; - BITMASK_ADD(mask, ACTOR_STATE_FACE_LEFT); - if ( mask != (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT) ) + AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_FACE_LEFT); + if ( mask != (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT) ) return 1; - BITMASK_DEL(mask, ACTOR_STATE_ALIVE); - if ( mask != (ACTOR_STATE_FACE_LEFT) ) + AKGL_BITMASK_DEL(mask, AKGL_ACTOR_STATE_ALIVE); + if ( mask != (AKGL_ACTOR_STATE_FACE_LEFT) ) return 1; - BITMASK_CLEAR(mask); + AKGL_BITMASK_CLEAR(mask); if ( mask != 0 ) return 1; - BITMASK_ADD(mask, ACTOR_STATE_FACE_LEFT); - if ( !(BITMASK_HAS(mask, ACTOR_STATE_FACE_LEFT)) ) + AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_FACE_LEFT); + if ( !(AKGL_BITMASK_HAS(mask, AKGL_ACTOR_STATE_FACE_LEFT)) ) return 1; - mask = ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_UP; - BITMASK_DEL(mask, ACTOR_STATE_FACE_ALL); - if ( mask != ACTOR_STATE_ALIVE ) + mask = AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_UP; + AKGL_BITMASK_DEL(mask, AKGL_ACTOR_STATE_FACE_ALL); + if ( mask != AKGL_ACTOR_STATE_ALIVE ) return 1; - BITMASK_ADD(mask, ACTOR_STATE_MOVING_DOWN); - BITMASK_ADD(mask, ACTOR_STATE_FACE_DOWN); - if ( mask != (ACTOR_STATE_ALIVE | ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_DOWN) ) + AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_MOVING_DOWN); + AKGL_BITMASK_ADD(mask, AKGL_ACTOR_STATE_FACE_DOWN); + if ( mask != (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_DOWN) ) return 1; return 0; } diff --git a/tests/character.c b/tests/character.c index 83283c0..19da2de 100644 --- a/tests/character.c +++ b/tests/character.c @@ -11,16 +11,16 @@ SDL_Window *window; SDL_Renderer *renderer; -akerr_ErrorContext *test_character_initialize() +akerr_ErrorContext *test_akgl_character_initialize() { PREPARE_ERROR(errctx); - character *testchar = NULL; + akgl_Character *testchar = NULL; ATTEMPT { - CATCH(errctx, heap_next_character(&testchar)); - CATCH(errctx, character_initialize(testchar, "testchar")); + CATCH(errctx, akgl_heap_next_character(&testchar)); + CATCH(errctx, akgl_character_initialize(testchar, "testchar")); FAIL_ZERO_BREAK( errctx, - SDL_GetPointerProperty(REGISTRY_CHARACTER, "testchar", NULL), + SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, "testchar", NULL), AKERR_KEY, "Character was not placed in the registry"); FAIL_NONZERO_BREAK( @@ -35,7 +35,7 @@ akerr_ErrorContext *test_character_initialize() AKERR_NULLPOINTER, "Character state sprites map was not initialized"); } CLEANUP { - IGNORE(heap_release_character(testchar)); + IGNORE(akgl_heap_release_character(testchar)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); @@ -43,37 +43,37 @@ akerr_ErrorContext *test_character_initialize() akerr_ErrorContext *test_character_sprite_mgmt() { - character *testchar = NULL; - sprite *testsprite = NULL; - sprite *testsprite2 = NULL; - sprite *comparesprite = NULL; + akgl_Character *testchar = NULL; + akgl_Sprite *testsprite = NULL; + akgl_Sprite *testsprite2 = NULL; + akgl_Sprite *comparesprite = NULL; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, heap_next_character(&testchar)); - CATCH(errctx, sprite_load_json("assets/testsprite.json")); - testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL); + CATCH(errctx, akgl_heap_next_character(&testchar)); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json")); + testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL); FAIL_ZERO_BREAK( errctx, testsprite, AKERR_KEY, "Sprite loaded from json but not in registry"); - CATCH(errctx, sprite_load_json("assets/testsprite2.json")); - testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json")); + testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL); FAIL_ZERO_BREAK( errctx, testsprite2, AKERR_KEY, "Sprite 2 loaded from json but not in registry"); - CATCH(errctx, testchar->sprite_add(testchar, testsprite, ACTOR_STATE_ALIVE)); - CATCH(errctx, testchar->sprite_add(testchar, testsprite2, ACTOR_STATE_DEAD)); - CATCH(errctx, testchar->sprite_get(testchar, (ACTOR_STATE_ALIVE), &comparesprite)); - FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT"); - CATCH(errctx, testchar->sprite_get(testchar, ACTOR_STATE_DEAD, &comparesprite)); - FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_DEAD"); + CATCH(errctx, testchar->sprite_add(testchar, testsprite, AKGL_ACTOR_STATE_ALIVE)); + CATCH(errctx, testchar->sprite_add(testchar, testsprite2, AKGL_ACTOR_STATE_DEAD)); + CATCH(errctx, testchar->sprite_get(testchar, (AKGL_ACTOR_STATE_ALIVE), &comparesprite)); + FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT"); + CATCH(errctx, testchar->sprite_get(testchar, AKGL_ACTOR_STATE_DEAD, &comparesprite)); + FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_DEAD"); } CLEANUP { - IGNORE(heap_release_sprite(testsprite)); - IGNORE(heap_release_sprite(testsprite2)); - IGNORE(heap_release_character(testchar)); + IGNORE(akgl_heap_release_sprite(testsprite)); + IGNORE(akgl_heap_release_sprite(testsprite2)); + IGNORE(akgl_heap_release_character(testchar)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); @@ -81,103 +81,103 @@ akerr_ErrorContext *test_character_sprite_mgmt() akerr_ErrorContext *test_character_iterate_state_sprites() { - character *testchar = NULL; - sprite *testsprite = NULL; - sprite *testsprite2 = NULL; - iterator opflags = {.flags = ITERATOR_OP_RELEASE, .layerid = 0}; + akgl_Character *testchar = NULL; + akgl_Sprite *testsprite = NULL; + akgl_Sprite *testsprite2 = NULL; + akgl_Iterator opflags = {.flags = AKGL_ITERATOR_OP_RELEASE, .layerid = 0}; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, heap_next_character(&testchar)); - CATCH(errctx, sprite_load_json("assets/testsprite.json")); - testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL); + CATCH(errctx, akgl_heap_next_character(&testchar)); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json")); + testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL); FAIL_ZERO_BREAK( errctx, testsprite, AKERR_KEY, "Sprite loaded from json but not in registry"); - CATCH(errctx, sprite_load_json("assets/testsprite2.json")); - testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json")); + testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL); FAIL_ZERO_BREAK( errctx, testsprite2, AKERR_KEY, "Sprite 2 loaded from json but not in registry"); - CATCH(errctx, testchar->sprite_add(testchar, testsprite, ACTOR_STATE_ALIVE)); - CATCH(errctx, testchar->sprite_add(testchar, testsprite2, ACTOR_STATE_DEAD)); + CATCH(errctx, testchar->sprite_add(testchar, testsprite, AKGL_ACTOR_STATE_ALIVE)); + CATCH(errctx, testchar->sprite_add(testchar, testsprite2, AKGL_ACTOR_STATE_DEAD)); - SDL_EnumerateProperties(testchar->state_sprites, &character_state_sprites_iterate, &opflags); + SDL_EnumerateProperties(testchar->state_sprites, &akgl_character_state_sprites_iterate, &opflags); - // This is called by heap_release_character so we should assume that our property map is being + // This is called by akgl_heap_release_character so we should assume that our property map is being // deleted soon after this. So we don't care if the sprites have been deleted from the sprite_states. // We just want to know they've been released. FAIL_NONZERO_BREAK( errctx, (testsprite->refcount > 1), AKERR_VALUE, - "heap_release_sprite not called for testsprite from iterator"); + "akgl_heap_release_sprite not called for testsprite from iterator"); FAIL_NONZERO_BREAK( errctx, (testsprite2->refcount > 1), AKERR_VALUE, - "heap_release_sprite not called for testsprite from iterator"); + "akgl_heap_release_sprite not called for testsprite from iterator"); } CLEANUP { - IGNORE(heap_release_sprite(testsprite)); - IGNORE(heap_release_sprite(testsprite2)); - IGNORE(heap_release_character(testchar)); + IGNORE(akgl_heap_release_sprite(testsprite)); + IGNORE(akgl_heap_release_sprite(testsprite2)); + IGNORE(akgl_heap_release_character(testchar)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_character_load_json() +akerr_ErrorContext *test_akgl_character_load_json() { - character *testcharacter = NULL; - sprite *testsprite = NULL; - sprite *testsprite2 = NULL; - sprite *comparesprite = NULL; + akgl_Character *testcharacter = NULL; + akgl_Sprite *testsprite = NULL; + akgl_Sprite *testsprite2 = NULL; + akgl_Sprite *comparesprite = NULL; int tsrc = 0; int tsrc2 = 0; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, heap_next_character(&testcharacter)); - CATCH(errctx, sprite_load_json("assets/testsprite.json")); - testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL); + CATCH(errctx, akgl_heap_next_character(&testcharacter)); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json")); + testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL); FAIL_ZERO_BREAK( errctx, testsprite, AKERR_KEY, "Sprite loaded from json but not in registry"); - CATCH(errctx, sprite_load_json("assets/testsprite2.json")); - testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json")); + testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL); FAIL_ZERO_BREAK( errctx, testsprite2, AKERR_KEY, "Sprite 2 loaded from json but not in registry"); - CATCH(errctx, character_load_json("assets/testcharacter.json")); - testcharacter = SDL_GetPointerProperty(REGISTRY_CHARACTER, "testcharacter", NULL); + CATCH(errctx, akgl_character_load_json("assets/testcharacter.json")); + testcharacter = SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, "testcharacter", NULL); FAIL_ZERO_BREAK( errctx, testcharacter, AKERR_KEY, "Character loaded from json but not in registry"); - CATCH(errctx, testcharacter->sprite_get(testcharacter, (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT), &comparesprite)); - FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_ALIVE"); - CATCH(errctx, testcharacter->sprite_get(testcharacter, ACTOR_STATE_DEAD, &comparesprite)); - FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state ACTOR_STATE_DEAD"); + CATCH(errctx, testcharacter->sprite_get(testcharacter, (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT), &comparesprite)); + FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_ALIVE"); + CATCH(errctx, testcharacter->sprite_get(testcharacter, AKGL_ACTOR_STATE_DEAD, &comparesprite)); + FAIL_ZERO_BREAK(errctx, (comparesprite == testsprite2), AKERR_VALUE, "Wrong sprite for state AKGL_ACTOR_STATE_DEAD"); FAIL_ZERO_BREAK(errctx, (testcharacter->vx != 0.200000003), AKERR_VALUE, "Wrong X velocity for test character"); FAIL_ZERO_BREAK(errctx, (testcharacter->vy != 0.200000003), AKERR_VALUE, "Wrong Y velocity for test character"); // Release our handles on the sprites so the character's heap_release can reduce them to 0 - CATCH(errctx, heap_release_sprite(testsprite)); - CATCH(errctx, heap_release_sprite(testsprite2)); + CATCH(errctx, akgl_heap_release_sprite(testsprite)); + CATCH(errctx, akgl_heap_release_sprite(testsprite2)); tsrc = testsprite->refcount; tsrc2 = testsprite2->refcount; - CATCH(errctx, heap_release_character(testcharacter)); + CATCH(errctx, akgl_heap_release_character(testcharacter)); FAIL_ZERO_BREAK( errctx, ((testsprite->refcount < tsrc) || (testsprite2->refcount < tsrc2)), @@ -196,19 +196,19 @@ int main(void) SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest"); if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); } if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_character", 640, 480, SDL_WINDOW_HIDDEN, &window, &renderer)) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); } - CATCH(errctx, heap_init()); - CATCH(errctx, registry_init()); - CATCH(errctx, test_character_initialize()); + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_registry_init()); + CATCH(errctx, test_akgl_character_initialize()); CATCH(errctx, test_character_sprite_mgmt()); CATCH(errctx, test_character_iterate_state_sprites()); - CATCH(errctx, test_character_load_json()); + CATCH(errctx, test_akgl_character_load_json()); } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); diff --git a/tests/charviewer.c b/tests/charviewer.c index d668c5c..b767a6b 100644 --- a/tests/charviewer.c +++ b/tests/charviewer.c @@ -40,15 +40,15 @@ int main(void) SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest"); if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); } if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_sprite", 640, 480, 0, &window, &renderer)) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); } - CATCH(errctx, heap_init()); - CATCH(errctx, registry_init()); + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_registry_init()); strcpy((char *)&game.name, "charviewer"); strcpy((char *)&game.version, "0.0.1"); @@ -56,21 +56,21 @@ int main(void) game.screenwidth = 640; game.screenheight = 480; - CATCH(errctx, GAME_init()); + CATCH(errctx, akgl_GAME_init()); for ( int i = 0; i < numsprites ; i++) { - CATCH(errctx, sprite_load_json(spritepaths[i])); + CATCH(errctx, akgl_sprite_load_json(spritepaths[i])); } - CATCH(errctx, character_load_json("assets/characters/littleguy.json")); - CATCH(errctx, heap_next_actor(&actorptr)); - CATCH(errctx, actor_initialize((actor *)actorptr, "player")); + CATCH(errctx, akgl_character_load_json("assets/characters/littleguy.json")); + CATCH(errctx, akgl_heap_next_actor(&actorptr)); + CATCH(errctx, akgl_actor_initialize((actor *)actorptr, "player")); actorptr->basechar = SDL_GetPointerProperty( - REGISTRY_CHARACTER, + AKGL_REGISTRY_CHARACTER, "little guy", NULL); FAIL_ZERO_BREAK(errctx, actorptr->basechar, AKERR_REGISTRY, "Can't load character 'little guy' from the registry"); actorptr->movement_controls_face = false; - actorptr->state = (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT); + actorptr->state = (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT); actorptr->x = 320; actorptr->y = 240; actorptr->visible = true; @@ -78,40 +78,40 @@ int main(void) // set up the control map controlmap = &GAME_ControlMaps[0]; controlmap->kbid = 0; - controlmap->target = SDL_GetPointerProperty(REGISTRY_ACTOR, "player", NULL); + controlmap->target = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "player", NULL); // Move down controlmap->controls[0].key = SDLK_DOWN; - //controlmap->controls[0].target_state_gate = ACTOR_STATE_MOVING_DOWN; - controlmap->controls[0].target_add_state_on = ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_DOWN; - controlmap->controls[0].target_del_state_on = ACTOR_STATE_MOVING_UP | ACTOR_STATE_FACE_ALL; - controlmap->controls[0].target_del_state_off = ACTOR_STATE_MOVING_DOWN; + //controlmap->controls[0].target_state_gate = AKGL_ACTOR_STATE_MOVING_DOWN; + controlmap->controls[0].target_add_state_on = AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_DOWN; + controlmap->controls[0].target_del_state_on = AKGL_ACTOR_STATE_MOVING_UP | AKGL_ACTOR_STATE_FACE_ALL; + controlmap->controls[0].target_del_state_off = AKGL_ACTOR_STATE_MOVING_DOWN; controlmap->controls[0].event_on = SDL_EVENT_KEY_DOWN; controlmap->controls[0].event_off = SDL_EVENT_KEY_UP; // Move up controlmap->controls[1].key = SDLK_UP; - //controlmap->controls[1].target_state_gate = ACTOR_STATE_MOVING_UP; - controlmap->controls[1].target_add_state_on = ACTOR_STATE_MOVING_UP | ACTOR_STATE_FACE_UP; - controlmap->controls[1].target_del_state_on = ACTOR_STATE_MOVING_DOWN | ACTOR_STATE_FACE_ALL; - controlmap->controls[1].target_del_state_off = ACTOR_STATE_MOVING_UP; + //controlmap->controls[1].target_state_gate = AKGL_ACTOR_STATE_MOVING_UP; + controlmap->controls[1].target_add_state_on = AKGL_ACTOR_STATE_MOVING_UP | AKGL_ACTOR_STATE_FACE_UP; + controlmap->controls[1].target_del_state_on = AKGL_ACTOR_STATE_MOVING_DOWN | AKGL_ACTOR_STATE_FACE_ALL; + controlmap->controls[1].target_del_state_off = AKGL_ACTOR_STATE_MOVING_UP; controlmap->controls[1].event_on = SDL_EVENT_KEY_DOWN; controlmap->controls[1].event_off = SDL_EVENT_KEY_UP; // Move left controlmap->controls[2].key = SDLK_LEFT; - //controlmap->controls[2].target_state_gate = ACTOR_STATE_MOVING_LEFT; - controlmap->controls[2].target_add_state_on = ACTOR_STATE_MOVING_LEFT | ACTOR_STATE_FACE_LEFT; - controlmap->controls[2].target_del_state_on = ACTOR_STATE_MOVING_RIGHT | ACTOR_STATE_FACE_ALL; - controlmap->controls[2].target_del_state_off = ACTOR_STATE_MOVING_LEFT; + //controlmap->controls[2].target_state_gate = AKGL_ACTOR_STATE_MOVING_LEFT; + controlmap->controls[2].target_add_state_on = AKGL_ACTOR_STATE_MOVING_LEFT | AKGL_ACTOR_STATE_FACE_LEFT; + controlmap->controls[2].target_del_state_on = AKGL_ACTOR_STATE_MOVING_RIGHT | AKGL_ACTOR_STATE_FACE_ALL; + controlmap->controls[2].target_del_state_off = AKGL_ACTOR_STATE_MOVING_LEFT; controlmap->controls[2].event_on = SDL_EVENT_KEY_DOWN; controlmap->controls[2].event_off = SDL_EVENT_KEY_UP; // Move right controlmap->controls[3].key = SDLK_RIGHT; - //controlmap->controls[3].target_state_gate = ACTOR_STATE_MOVING_RIGHT; - controlmap->controls[3].target_add_state_on = ACTOR_STATE_MOVING_RIGHT | ACTOR_STATE_FACE_RIGHT; - controlmap->controls[3].target_del_state_on = ACTOR_STATE_MOVING_LEFT | ACTOR_STATE_FACE_ALL; - controlmap->controls[3].target_del_state_off = ACTOR_STATE_MOVING_RIGHT; + //controlmap->controls[3].target_state_gate = AKGL_ACTOR_STATE_MOVING_RIGHT; + controlmap->controls[3].target_add_state_on = AKGL_ACTOR_STATE_MOVING_RIGHT | AKGL_ACTOR_STATE_FACE_RIGHT; + controlmap->controls[3].target_del_state_on = AKGL_ACTOR_STATE_MOVING_LEFT | AKGL_ACTOR_STATE_FACE_ALL; + controlmap->controls[3].target_del_state_off = AKGL_ACTOR_STATE_MOVING_RIGHT; controlmap->controls[3].event_on = SDL_EVENT_KEY_DOWN; controlmap->controls[3].event_off = SDL_EVENT_KEY_UP; } CLEANUP { diff --git a/tests/registry.c b/tests/registry.c index 23c941d..41f9292 100644 --- a/tests/registry.c +++ b/tests/registry.c @@ -11,7 +11,7 @@ void *sdl_calloc_always_fails(size_t a, size_t b) return NULL; } -akerr_ErrorContext *test_registry_init(RegistryFuncPtr funcptr) +akerr_ErrorContext *test_akgl_registry_init(RegistryFuncPtr funcptr) { SDL_malloc_func malloc_func; SDL_calloc_func calloc_func; @@ -46,11 +46,11 @@ akerr_ErrorContext *test_registry_init(RegistryFuncPtr funcptr) FAIL_RETURN(errctx, AKERR_BEHAVIOR, "SDL memory allocator fails but registry reports successful property creation"); } -akerr_ErrorContext *test_registry_init_creation_failures(void) +akerr_ErrorContext *test_akgl_registry_init_creation_failures(void) { PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, test_registry_init(®istry_init_actor)); + CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_actor)); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -58,7 +58,7 @@ akerr_ErrorContext *test_registry_init_creation_failures(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, test_registry_init(®istry_init_sprite)); + CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_sprite)); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -66,7 +66,7 @@ akerr_ErrorContext *test_registry_init_creation_failures(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, test_registry_init(®istry_init_spritesheet)); + CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_spritesheet)); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -74,7 +74,7 @@ akerr_ErrorContext *test_registry_init_creation_failures(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, test_registry_init(®istry_init_character)); + CATCH(errctx, test_akgl_registry_init(&akgl_registry_init_character)); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -87,7 +87,7 @@ int main(void) { PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, test_registry_init_creation_failures()); + CATCH(errctx, test_akgl_registry_init_creation_failures()); } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); diff --git a/tests/sprite.c b/tests/sprite.c index 43bbaef..2ba3dae 100644 --- a/tests/sprite.c +++ b/tests/sprite.c @@ -14,35 +14,35 @@ SDL_Window *window; SDL_Renderer *renderer; -akerr_ErrorContext *test_spritesheet_initialize(void) +akerr_ErrorContext *test_akgl_spritesheet_initialize(void) { PREPARE_ERROR(errctx); - spritesheet *sheet = NULL; + akgl_SpriteSheet *sheet = NULL; SDL_Texture *image = NULL; - string *tmpstr = NULL; + akgl_String *tmpstr = NULL; // Does the image file get loaded? // Is the image file loaded correctly? (Surface comparison) // Is the spritesheet in the registry? ATTEMPT { - CATCH(errctx, heap_next_spritesheet(&sheet)); - CATCH(errctx, heap_next_string(&tmpstr)); + CATCH(errctx, akgl_heap_next_spritesheet(&sheet)); + CATCH(errctx, akgl_heap_next_string(&tmpstr)); - snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); - CATCH(errctx, spritesheet_initialize(sheet, 48, 48, "assets/spritesheet.png")); - FAIL_ZERO_BREAK(errctx, sheet->texture, AKERR_VALUE, "spritesheet_initialize failed to load the sprite texture"); + snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); + CATCH(errctx, akgl_spritesheet_initialize(sheet, 48, 48, "assets/spritesheet.png")); + FAIL_ZERO_BREAK(errctx, sheet->texture, AKERR_VALUE, "akgl_spritesheet_initialize failed to load the sprite texture"); FAIL_NONZERO_BREAK( errctx, ((sheet->texture->w != 576) || (sheet->texture->h != 384)), AKERR_VALUE, "Loaded texture was not the correct size"); - snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); + snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); image = IMG_LoadTexture(renderer, (char *)&tmpstr->data); - FAIL_ZERO_BREAK(errctx, image, AKERR_SDL, "Failed to load comparison image"); + FAIL_ZERO_BREAK(errctx, image, AKGL_ERR_SDL, "Failed to load comparison image"); CATCH( errctx, - render_and_compare( + akgl_render_and_compare( sheet->texture, image, 0, 0, 576, 384, @@ -51,13 +51,13 @@ akerr_ErrorContext *test_spritesheet_initialize(void) FAIL_ZERO_BREAK( errctx, - SDL_GetPointerProperty(REGISTRY_SPRITESHEET, "assets/spritesheet.png", NULL), + SDL_GetPointerProperty(AKGL_AKGL_REGISTRY_SPRITESHEET, "assets/spritesheet.png", NULL), AKERR_KEY, "Spritesheet was not placed in the registry"); } CLEANUP { - IGNORE(heap_release_string(tmpstr)); - IGNORE(heap_release_spritesheet(sheet)); + IGNORE(akgl_heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_spritesheet(sheet)); if ( image != NULL ) SDL_DestroyTexture(image); } PROCESS(errctx) { @@ -65,48 +65,48 @@ akerr_ErrorContext *test_spritesheet_initialize(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_sprite_initialize(void) +akerr_ErrorContext *test_akgl_sprite_initialize(void) { PREPARE_ERROR(errctx); - spritesheet *testsheet = NULL; - sprite *testsprite = NULL; - string *tmpstr = NULL; + akgl_SpriteSheet *testsheet = NULL; + akgl_Sprite *testsprite = NULL; + akgl_String *tmpstr = NULL; // Does the sprite get loaded? // Do all frames of the sprite get loaded? // Are all the frames of the sprite what we expect? (Surface comparison) // Is the sprite added to the registry? ATTEMPT { - CATCH(errctx, heap_next_spritesheet(&testsheet)); - CATCH(errctx, heap_next_sprite(&testsprite)); - CATCH(errctx, heap_next_string(&tmpstr)); + CATCH(errctx, akgl_heap_next_spritesheet(&testsheet)); + CATCH(errctx, akgl_heap_next_sprite(&testsprite)); + CATCH(errctx, akgl_heap_next_string(&tmpstr)); - snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); - CATCH(errctx, spritesheet_initialize(testsheet, 48, 48, "assets/spritesheet.png")); - FAIL_ZERO_BREAK(errctx, testsheet, AKERR_VALUE, "spritesheet_initialize failed"); + snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); + CATCH(errctx, akgl_spritesheet_initialize(testsheet, 48, 48, "assets/spritesheet.png")); + FAIL_ZERO_BREAK(errctx, testsheet, AKERR_VALUE, "akgl_spritesheet_initialize failed"); - CATCH(errctx, sprite_initialize(testsprite, "test", testsheet)); + CATCH(errctx, akgl_sprite_initialize(testsprite, "test", testsheet)); FAIL_NONZERO_BREAK(errctx, (testsprite->sheet != testsheet), AKERR_VALUE, "Initialized sprite uses wrong sheet"); FAIL_ZERO_BREAK( errctx, - SDL_GetPointerProperty(REGISTRY_SPRITE, "test", NULL), + SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "test", NULL), AKERR_KEY, "Sprite was not placed in the registry"); } CLEANUP { - IGNORE(heap_release_sprite(testsprite)); - IGNORE(heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_sprite(testsprite)); + IGNORE(akgl_heap_release_string(tmpstr)); } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_sprite_load_json(void) +akerr_ErrorContext *test_akgl_sprite_load_json(void) { PREPARE_ERROR(errctx); - sprite *testsprite = NULL; - sprite *testsprite2 = NULL; - string *tmpstr = NULL; + akgl_Sprite *testsprite = NULL; + akgl_Sprite *testsprite2 = NULL; + akgl_String *tmpstr = NULL; SDL_Texture *image = NULL; // Does the sprite get loaded? @@ -114,15 +114,15 @@ akerr_ErrorContext *test_sprite_load_json(void) // Are all the frames of the sprite what we expect? (Surface comparison) // Is the sprite added to the registry? ATTEMPT { - CATCH(errctx, heap_next_string(&tmpstr)); + CATCH(errctx, akgl_heap_next_string(&tmpstr)); - CATCH(errctx, sprite_load_json("assets/testsprite.json")); - testsprite = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite", NULL); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json")); + testsprite = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite", NULL); FAIL_ZERO_BREAK( errctx, testsprite, AKERR_KEY, - "sprite_load_json succeeds but sprite is not placed in the registry"); + "akgl_sprite_load_json succeeds but sprite is not placed in the registry"); 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); @@ -137,13 +137,13 @@ akerr_ErrorContext *test_sprite_load_json(void) // Is it using the right spritesheet? - snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); + snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/spritesheet.png"); image = IMG_LoadTexture(renderer, (char *)&tmpstr->data); - FAIL_ZERO_BREAK(errctx, image, AKERR_SDL, "Failed to load comparison image"); + FAIL_ZERO_BREAK(errctx, image, AKGL_ERR_SDL, "Failed to load comparison image"); CATCH( errctx, - render_and_compare( + akgl_render_and_compare( testsprite->sheet->texture, image, 0, 0, 576, 384, @@ -152,14 +152,14 @@ akerr_ErrorContext *test_sprite_load_json(void) ); // If we load a second sprite using the same sheet name, do they use the same sheet in memory? - snprintf((char *)&tmpstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testsprite2.json"); - CATCH(errctx, sprite_load_json("assets/testsprite2.json")); - testsprite2 = SDL_GetPointerProperty(REGISTRY_SPRITE, "testsprite2", NULL); + snprintf((char *)&tmpstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testsprite2.json"); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json")); + testsprite2 = SDL_GetPointerProperty(AKGL_REGISTRY_SPRITE, "testsprite2", NULL); FAIL_ZERO_BREAK( errctx, testsprite, AKERR_KEY, - "sprite_load_json succeeds but second sprite is not placed in the registry"); + "akgl_sprite_load_json succeeds but second sprite is not placed in the registry"); FAIL_ZERO_BREAK( errctx, @@ -169,12 +169,12 @@ akerr_ErrorContext *test_sprite_load_json(void) } CLEANUP { if ( testsprite != NULL ) { - IGNORE(heap_release_sprite(testsprite)); + IGNORE(akgl_heap_release_sprite(testsprite)); } if ( testsprite2 != NULL ) { - IGNORE(heap_release_sprite(testsprite2)); + IGNORE(akgl_heap_release_sprite(testsprite2)); } - IGNORE(heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_string(tmpstr)); if ( image != NULL ) SDL_DestroyTexture(image); } PROCESS(errctx) { @@ -191,20 +191,20 @@ int main(void) SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest"); if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); } if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_sprite", 640, 480, 0, &window, &renderer)) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); } - CATCH(errctx, heap_init()); - CATCH(errctx, registry_init_sprite()); - CATCH(errctx, registry_init_spritesheet()); + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_registry_init_sprite()); + CATCH(errctx, akgl_registry_init_spritesheet()); - CATCH(errctx, test_spritesheet_initialize()); - CATCH(errctx, test_sprite_initialize()); - CATCH(errctx, test_sprite_load_json()); + CATCH(errctx, test_akgl_spritesheet_initialize()); + CATCH(errctx, test_akgl_sprite_initialize()); + CATCH(errctx, test_akgl_sprite_load_json()); } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); diff --git a/tests/staticstring.c b/tests/staticstring.c index 4859419..12293b7 100644 --- a/tests/staticstring.c +++ b/tests/staticstring.c @@ -7,12 +7,12 @@ void reset_string_heap(void); akerr_ErrorContext *test_fresh_heap_gives_strings(void) { - string *ptr = NULL; + akgl_String *ptr = NULL; PREPARE_ERROR(errctx); - for ( int i = 0; i < MAX_HEAP_STRING - 1; i++ ) { + for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) { ATTEMPT { - CATCH(errctx, heap_next_string(&ptr)); + CATCH(errctx, akgl_heap_next_string(&ptr)); } CLEANUP { reset_string_heap(); } PROCESS(errctx) { @@ -24,14 +24,14 @@ akerr_ErrorContext *test_fresh_heap_gives_strings(void) akerr_ErrorContext *test_string_heap_error_when_no_strings_left(void) { - string *ptr; + akgl_String *ptr; PREPARE_ERROR(errctx); - for ( int i = 0; i < MAX_HEAP_STRING; i++ ) { + for ( int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) { HEAP_STRING[i].refcount = 1; } - for ( int i = 0; i < MAX_HEAP_STRING - 1; i++ ) { + for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) { ATTEMPT { - CATCH(errctx, heap_next_string(&ptr)); + CATCH(errctx, akgl_heap_next_string(&ptr)); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -44,12 +44,12 @@ akerr_ErrorContext *test_string_heap_error_when_no_strings_left(void) akerr_ErrorContext *test_string_heap_honors_refcount(void) { - string *firstptr = &HEAP_STRING[0]; - string *secondptr = &HEAP_STRING[1]; - string *testptr = NULL; + akgl_String *firstptr = &HEAP_STRING[0]; + akgl_String *secondptr = &HEAP_STRING[1]; + akgl_String *testptr = NULL; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, heap_next_string(&testptr)); + CATCH(errctx, akgl_heap_next_string(&testptr)); if ( testptr != firstptr ) { FAIL_RETURN( errctx, @@ -59,7 +59,7 @@ akerr_ErrorContext *test_string_heap_honors_refcount(void) testptr ); } - CATCH(errctx, string_initialize(testptr, NULL)); + CATCH(errctx, akgl_string_initialize(testptr, NULL)); if ( testptr->refcount == 0 ) { FAIL_RETURN(errctx, AKERR_VALUE, "Expected string reference count to be nonzero but got 0"); } @@ -72,7 +72,7 @@ akerr_ErrorContext *test_string_heap_honors_refcount(void) testptr ); } - CATCH(errctx, heap_next_string(&testptr)); + CATCH(errctx, akgl_heap_next_string(&testptr)); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); @@ -81,14 +81,14 @@ akerr_ErrorContext *test_string_heap_honors_refcount(void) akerr_ErrorContext *test_strcpy_to_all_strings_no_segfault(void) { - char copybuf[MAX_STRING_LENGTH]; - string *ptr; - memset((void *)©buf, 'a', MAX_STRING_LENGTH); + char copybuf[AKGL_MAX_STRING_LENGTH]; + akgl_String *ptr; + memset((void *)©buf, 'a', AKGL_MAX_STRING_LENGTH); PREPARE_ERROR(errctx); ATTEMPT { - for ( int i = 0; i < MAX_HEAP_STRING - 1; i++ ) { - CATCH(errctx, heap_next_string(&ptr)); - strncpy(ptr->data, (char *)©buf, MAX_STRING_LENGTH); + for ( int i = 0; i < AKGL_MAX_HEAP_STRING - 1; i++ ) { + CATCH(errctx, akgl_heap_next_string(&ptr)); + strncpy(ptr->data, (char *)©buf, AKGL_MAX_STRING_LENGTH); } } CLEANUP { } PROCESS(errctx) { @@ -96,21 +96,21 @@ akerr_ErrorContext *test_strcpy_to_all_strings_no_segfault(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_string_initialize(void) +akerr_ErrorContext *test_akgl_string_initialize(void) { - string *ptr; + akgl_String *ptr; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, heap_next_string(&ptr)); - CATCH(errctx, string_initialize(ptr, NULL)); + CATCH(errctx, akgl_heap_next_string(&ptr)); + CATCH(errctx, akgl_string_initialize(ptr, NULL)); FAIL_NONZERO_BREAK(errctx, ptr->data[0], AKERR_VALUE, "Expected empty zero length string data"); - CATCH(errctx, heap_release_string(ptr)); - CATCH(errctx, heap_next_string(&ptr)); - CATCH(errctx, string_initialize(ptr, "Test value")); + CATCH(errctx, akgl_heap_release_string(ptr)); + CATCH(errctx, akgl_heap_next_string(&ptr)); + CATCH(errctx, akgl_string_initialize(ptr, "Test value")); FAIL_NONZERO_BREAK(errctx, strcmp((char *)&ptr->data, "Test value"), AKERR_VALUE, "Expected 'Test value', got %s", (char *)&ptr->data); - CATCH(errctx, heap_release_string(NULL)); + CATCH(errctx, akgl_heap_release_string(NULL)); FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Failure to properly handle NULL pointer"); } CLEANUP { } PROCESS(errctx) { @@ -122,8 +122,8 @@ akerr_ErrorContext *test_string_initialize(void) void reset_string_heap(void) { - for ( int i = 0; i < MAX_HEAP_STRING; i++ ) { - memset(&HEAP_STRING[i], 0x00, sizeof(string)); + for ( int i = 0; i < AKGL_MAX_HEAP_STRING; i++ ) { + memset(&HEAP_STRING[i], 0x00, sizeof(akgl_String)); } } @@ -144,8 +144,8 @@ int main(void) printf("test_strcpy_to_all_strings_no_segfault ...\n"); test_strcpy_to_all_strings_no_segfault(); reset_string_heap(); - printf("test_string_initialize....\n"); - test_string_initialize(); + printf("test_akgl_string_initialize....\n"); + test_akgl_string_initialize(); } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); diff --git a/tests/tilemap.c b/tests/tilemap.c index 37cb621..0b8d039 100644 --- a/tests/tilemap.c +++ b/tests/tilemap.c @@ -11,28 +11,28 @@ #include #include -akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void) +akerr_ErrorContext *test_tilemap_akgl_get_json_tilemap_property(void) { PREPARE_ERROR(errctx); json_t *jsondoc = NULL; json_error_t jsonerr; - string *tmpstr = NULL; + akgl_String *tmpstr = NULL; int propnum; ATTEMPT { - CATCH(errctx, heap_next_string(&tmpstr)); + CATCH(errctx, akgl_heap_next_string(&tmpstr)); snprintf( (char *)&tmpstr->data, - MAX_STRING_LENGTH, + AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), - "assets/snippets/test_tilemap_get_json_tilemap_property.json" + "assets/snippets/test_tilemap_akgl_get_json_tilemap_property.json" ); jsondoc = json_load_file((char *)&tmpstr->data, 0, (json_error_t *)&jsonerr); FAIL_ZERO_BREAK(errctx, jsondoc, AKERR_NULLPOINTER, "Failure loading json fixture: %s", (char *)jsonerr.text); CATCH( errctx, - get_json_properties_string( + akgl_get_json_properties_string( jsondoc, "character", &tmpstr @@ -47,7 +47,7 @@ akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void) ); CATCH( errctx, - get_json_properties_integer( + akgl_get_json_properties_integer( jsondoc, "state", &propnum @@ -62,7 +62,7 @@ akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void) ); } CLEANUP { if ( tmpstr != NULL ) { - IGNORE(heap_release_string(tmpstr)); + IGNORE(akgl_heap_release_string(tmpstr)); } if ( jsondoc != NULL ) { json_decref(jsondoc); @@ -72,7 +72,7 @@ akerr_ErrorContext *test_tilemap_get_json_tilemap_property(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void) +akerr_ErrorContext *test_akgl_tilemap_compute_tileset_offsets(void) { int comparison_values[8] = { 0, // Tile 0 X @@ -96,7 +96,7 @@ akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void) }; int i = 0; - memset((void *)&gamemap, 0x00, sizeof(tilemap)); + memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap)); gamemap.tilesets[0].tilecount = 4; gamemap.tilesets[0].columns = 2; gamemap.tilesets[0].firstgid = 1; @@ -110,7 +110,7 @@ akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void) PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, tilemap_compute_tileset_offsets(&gamemap, 0)); + CATCH(errctx, akgl_tilemap_compute_tileset_offsets(&gamemap, 0)); // Tile 0 X offset for ( i = 0; i < 8; i++ ) { FAIL_NONZERO_BREAK( @@ -129,34 +129,34 @@ akerr_ErrorContext *test_tilemap_compute_tileset_offsets(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_load_layer_objects(void) +akerr_ErrorContext *test_akgl_tilemap_load_layer_objects(void) { - string *pathstr; + akgl_String *pathstr; PREPARE_ERROR(errctx); json_t *doc = NULL; json_t *layers = NULL; json_t *objectlayer = NULL; json_error_t errdata; - actor *testactor; + akgl_Actor *testactor; - memset((void *)&gamemap, 0x00, sizeof(tilemap)); + memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap)); ATTEMPT { - CATCH(errctx, heap_next_string(&pathstr)); - snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); + CATCH(errctx, akgl_heap_next_string(&pathstr)); + snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); doc = json_load_file((char *)&pathstr->data, 0, &errdata); FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text); - CATCH(errctx, get_json_array_value(doc, "layers", &layers)); - CATCH(errctx, get_json_array_index_object(layers, 1, &objectlayer)); - CATCH(errctx, tilemap_load_layer_objects(&gamemap, objectlayer, 1)); + CATCH(errctx, akgl_get_json_array_value(doc, "layers", &layers)); + CATCH(errctx, akgl_get_json_array_index_object(layers, 1, &objectlayer)); + CATCH(errctx, akgl_tilemap_load_layer_objects(&gamemap, objectlayer, 1)); - testactor = SDL_GetPointerProperty(REGISTRY_ACTOR, "testactor", NULL); + testactor = SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "testactor", NULL); FAIL_ZERO_BREAK( errctx, testactor, AKERR_NULLPOINTER, "Test Actor was not loaded from the test map" ); - if ( (testactor->basechar != SDL_GetPointerProperty(REGISTRY_CHARACTER, "testcharacter", NULL)) || + if ( (testactor->basechar != SDL_GetPointerProperty(AKGL_REGISTRY_CHARACTER, "testcharacter", NULL)) || (testactor->layer != 1) || (testactor->state != 6) || (testactor->visible != true) || @@ -166,7 +166,7 @@ akerr_ErrorContext *test_tilemap_load_layer_objects(void) } } CLEANUP { if ( pathstr != NULL ) { - IGNORE(heap_release_string(pathstr)); + IGNORE(akgl_heap_release_string(pathstr)); } if ( doc != NULL ) { json_decref(doc); @@ -176,9 +176,9 @@ akerr_ErrorContext *test_tilemap_load_layer_objects(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_load_layer_tile(void) +akerr_ErrorContext *test_akgl_tilemap_load_layer_tile(void) { - string *pathstr; + akgl_String *pathstr; PREPARE_ERROR(errctx); json_t *doc = NULL; json_t *layers = NULL; @@ -186,17 +186,17 @@ akerr_ErrorContext *test_tilemap_load_layer_tile(void) json_t *tiledata = NULL; json_error_t errdata; - memset((void *)&gamemap, 0x00, sizeof(tilemap)); + memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap)); ATTEMPT { - CATCH(errctx, heap_next_string(&pathstr)); - snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); + CATCH(errctx, akgl_heap_next_string(&pathstr)); + snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); doc = json_load_file((char *)&pathstr->data, 0, &errdata); FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text); - CATCH(errctx, get_json_array_value(doc, "layers", &layers)); - CATCH(errctx, get_json_array_index_object(layers, 0, &tilelayer)); - CATCH(errctx, get_json_array_value(tilelayer, "data", &tiledata)); - CATCH(errctx, tilemap_load_layer_tile(&gamemap, tilelayer, 0)); + CATCH(errctx, akgl_get_json_array_value(doc, "layers", &layers)); + CATCH(errctx, akgl_get_json_array_index_object(layers, 0, &tilelayer)); + CATCH(errctx, akgl_get_json_array_value(tilelayer, "data", &tiledata)); + CATCH(errctx, akgl_tilemap_load_layer_tile(&gamemap, tilelayer, 0)); if ( (gamemap.layers[0].data[0] != 1) || (gamemap.layers[0].data[1] != 2) || (gamemap.layers[0].data[2] != 3) || @@ -205,7 +205,7 @@ akerr_ErrorContext *test_tilemap_load_layer_tile(void) } } CLEANUP { if ( pathstr != NULL ) { - IGNORE(heap_release_string(pathstr)); + IGNORE(akgl_heap_release_string(pathstr)); } if ( doc != NULL ) { json_decref(doc); @@ -215,22 +215,22 @@ akerr_ErrorContext *test_tilemap_load_layer_tile(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_load_layers(void) +akerr_ErrorContext *test_akgl_tilemap_load_layers(void) { - string *pathstr; + akgl_String *pathstr; PREPARE_ERROR(errctx); json_t *doc = NULL; json_error_t errdata; int i = 0; - memset((void *)&gamemap, 0x00, sizeof(tilemap)); + memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap)); ATTEMPT { - CATCH(errctx, heap_next_string(&pathstr)); - snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); + CATCH(errctx, akgl_heap_next_string(&pathstr)); + snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); doc = json_load_file((char *)&pathstr->data, 0, &errdata); FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text); - CATCH(errctx, tilemap_load_layers(&gamemap, doc)); + CATCH(errctx, akgl_tilemap_load_layers(&gamemap, doc)); FAIL_NONZERO_BREAK( errctx, (gamemap.numlayers != 3), @@ -244,26 +244,26 @@ akerr_ErrorContext *test_tilemap_load_layers(void) (gamemap.layers[i].x != 0) || (gamemap.layers[i].y != 0) ) { FAIL(errctx, AKERR_VALUE, "Map layer data loaded incorrectly (see gdb)"); - goto _test_tilemap_load_layers_cleanup; + goto _test_akgl_tilemap_load_layers_cleanup; } } // Layer 2 should have 1 object loaded - if ( (gamemap.layers[1].objects[0].actorptr != SDL_GetPointerProperty(REGISTRY_ACTOR, "testactor", NULL)) || + if ( (gamemap.layers[1].objects[0].actorptr != SDL_GetPointerProperty(AKGL_REGISTRY_ACTOR, "testactor", NULL)) || (gamemap.layers[1].objects[1].name[0] != '\0' ) || (gamemap.layers[1].objects[1].id != 0) ) { FAIL_BREAK(errctx, AKERR_VALUE, "Map layer 2 should have 1 loaded object (testactor) and nothing else (see gdb)"); } // Layer 1 and 3 should have no objects - for ( i = 0; i < TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) { + for ( i = 0; i < AKGL_TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) { if ( gamemap.layers[0].objects[i].id != 0 ) { FAIL(errctx, AKERR_VALUE, "Map layers 1 and 3 should have no objects loaded but found objects"); - goto _test_tilemap_load_layers_cleanup; + goto _test_akgl_tilemap_load_layers_cleanup; } } - for ( i = 0; i < TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) { + for ( i = 0; i < AKGL_TILEMAP_MAX_OBJECTS_PER_LAYER ; i++ ) { if ( gamemap.layers[2].objects[i].id != 0 ) { FAIL(errctx, AKERR_VALUE, "Map layers 1 and 3 should have no objects loaded but found objects"); - goto _test_tilemap_load_layers_cleanup; + goto _test_akgl_tilemap_load_layers_cleanup; } } // Layers 1 and 3 should have tile data @@ -278,10 +278,10 @@ akerr_ErrorContext *test_tilemap_load_layers(void) ) { FAIL_BREAK(errctx, AKERR_VALUE, "Map layers 1 and 3 should have tile data but it is incorrect"); } -_test_tilemap_load_layers_cleanup: +_test_akgl_tilemap_load_layers_cleanup: } CLEANUP { if ( pathstr != NULL ) { - IGNORE(heap_release_string(pathstr)); + IGNORE(akgl_heap_release_string(pathstr)); } if ( doc != NULL ) { json_decref(doc); @@ -291,22 +291,22 @@ _test_tilemap_load_layers_cleanup: SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_load_tilesets(void) +akerr_ErrorContext *test_akgl_tilemap_load_tilesets(void) { - string *pathstr = NULL; + akgl_String *pathstr = NULL; PREPARE_ERROR(errctx); json_t *doc = NULL; json_error_t errdata; SDL_Texture *image = NULL; - memset((void *)&gamemap, 0x00, sizeof(tilemap)); + memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap)); ATTEMPT { - CATCH(errctx, heap_next_string(&pathstr)); - snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); + CATCH(errctx, akgl_heap_next_string(&pathstr)); + snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/testmap.tmj"); doc = json_load_file((char *)&pathstr->data, 0, &errdata); FAIL_ZERO_BREAK(errctx, doc, AKERR_NULLPOINTER, "Failed to load testmap: %s", (char *)&errdata.text); - CATCH(errctx, tilemap_load_tilesets(&gamemap, doc)); + CATCH(errctx, akgl_tilemap_load_tilesets(&gamemap, doc)); FAIL_NONZERO_BREAK(errctx, (gamemap.numtilesets != 1), AKERR_VALUE, "Incorrect number of tilesets loaded for map"); if ( (gamemap.tilesets[0].columns != 48 ) || (gamemap.tilesets[0].firstgid != 1) || @@ -325,22 +325,22 @@ akerr_ErrorContext *test_tilemap_load_tilesets(void) AKERR_VALUE, "Tileset loaded with incorrect name"); - snprintf((char *)&pathstr->data, MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/World_A1.png"); + snprintf((char *)&pathstr->data, AKGL_MAX_STRING_LENGTH, "%s%s", SDL_GetBasePath(), "assets/World_A1.png"); image = IMG_LoadTexture(renderer, (char *)&pathstr->data); - FAIL_ZERO_BREAK(errctx, image, AKERR_SDL, "Failed to load comparison image"); + FAIL_ZERO_BREAK(errctx, image, AKGL_ERR_SDL, "Failed to load comparison image"); CATCH( errctx, - render_and_compare( + akgl_render_and_compare( gamemap.tilesets[0].texture, image, 0, 0, 768, 576, - "test_tilemap_loaded_tileset.png") + "test_akgl_tilemap_loaded_tileset.png") ); } CLEANUP { if ( pathstr != NULL ) { - IGNORE(heap_release_string(pathstr)); + IGNORE(akgl_heap_release_string(pathstr)); } if ( doc != NULL ) { json_decref(doc); @@ -350,21 +350,21 @@ akerr_ErrorContext *test_tilemap_load_tilesets(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_load(void) +akerr_ErrorContext *test_akgl_tilemap_load(void) { PREPARE_ERROR(errctx); - memset((void *)&gamemap, 0x00, sizeof(tilemap)); + memset((void *)&gamemap, 0x00, sizeof(akgl_Tilemap)); ATTEMPT { - CATCH(errctx, tilemap_load("assets/testmap.tmj", &gamemap)); + CATCH(errctx, akgl_tilemap_load("assets/testmap.tmj", &gamemap)); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_tilemap_draw(void) +akerr_ErrorContext *test_akgl_tilemap_draw(void) { PREPARE_ERROR(errctx); @@ -376,7 +376,7 @@ akerr_ErrorContext *test_tilemap_draw(void) } -akerr_ErrorContext *test_tilemap_draw_tileset(void) +akerr_ErrorContext *test_akgl_tilemap_draw_tileset(void) { PREPARE_ERROR(errctx); @@ -395,28 +395,28 @@ int main(void) SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest"); if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO )) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't initialize SDL: %s", SDL_GetError()); } if (!SDL_CreateWindowAndRenderer("net/aklabs/libsdl3game/test_sprite", 768, 576, 0, &window, &renderer)) { - FAIL_BREAK(errctx, AKERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); + FAIL_BREAK(errctx, AKGL_ERR_SDL, "Couldn't create window/renderer: %s", SDL_GetError()); } - CATCH(errctx, registry_init()); - CATCH(errctx, heap_init()); - CATCH(errctx, sprite_load_json("assets/testsprite.json")); - CATCH(errctx, sprite_load_json("assets/testsprite2.json")); - CATCH(errctx, character_load_json("assets/testcharacter.json")); + CATCH(errctx, akgl_registry_init()); + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite.json")); + CATCH(errctx, akgl_sprite_load_json("assets/testsprite2.json")); + CATCH(errctx, akgl_character_load_json("assets/testcharacter.json")); - CATCH(errctx, test_tilemap_get_json_tilemap_property()); - CATCH(errctx, test_tilemap_compute_tileset_offsets()); - CATCH(errctx, test_tilemap_load_layer_objects()); - CATCH(errctx, test_tilemap_load_layer_tile()); - CATCH(errctx, test_tilemap_load_layers()); - CATCH(errctx, test_tilemap_load_tilesets()); - //CATCH(errctx, test_tilemap_load()); - //CATCH(errctx, test_tilemap_draw_tileset()); - //CATCH(errctx, test_tilemap_draw()); + CATCH(errctx, test_tilemap_akgl_get_json_tilemap_property()); + CATCH(errctx, test_akgl_tilemap_compute_tileset_offsets()); + CATCH(errctx, test_akgl_tilemap_load_layer_objects()); + CATCH(errctx, test_akgl_tilemap_load_layer_tile()); + CATCH(errctx, test_akgl_tilemap_load_layers()); + CATCH(errctx, test_akgl_tilemap_load_tilesets()); + //CATCH(errctx, test_akgl_tilemap_load()); + //CATCH(errctx, test_akgl_tilemap_draw_tileset()); + //CATCH(errctx, test_akgl_tilemap_draw()); } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); diff --git a/tests/util.c b/tests/util.c index 3c8438f..532bd3c 100644 --- a/tests/util.c +++ b/tests/util.c @@ -2,15 +2,15 @@ #include #include -akerr_ErrorContext *test_rectangle_points_nullpointers(void) +akerr_ErrorContext *test_akgl_rectangle_points_nullpointers(void) { RectanglePoints points; SDL_FRect testrect; PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, rectangle_points(NULL, NULL)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "rectangle_points fails to FAIL with all NULL pointers"); + CATCH(errctx, akgl_rectangle_points(NULL, NULL)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with all NULL pointers"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -18,8 +18,8 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, rectangle_points(NULL, &testrect)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "rectangle_points fails to FAIL with NULL SDL_FRect pointer"); + CATCH(errctx, akgl_rectangle_points(NULL, &testrect)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with NULL SDL_FRect pointer"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -27,8 +27,8 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, rectangle_points(&points, NULL)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "rectangle_points fails to FAIL with NULL RectanglePoints pointer"); + CATCH(errctx, akgl_rectangle_points(&points, NULL)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_rectangle_points fails to FAIL with NULL RectanglePoints pointer"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -36,7 +36,7 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, rectangle_points(&points, &testrect)); + CATCH(errctx, akgl_rectangle_points(&points, &testrect)); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); @@ -44,7 +44,7 @@ akerr_ErrorContext *test_rectangle_points_nullpointers(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_rectangle_points_math(void) +akerr_ErrorContext *test_akgl_rectangle_points_math(void) { RectanglePoints points; SDL_FRect testrect = {.x = 0, .y = 0, .w = 32, .h = 32}; @@ -52,7 +52,7 @@ akerr_ErrorContext *test_rectangle_points_math(void) PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, rectangle_points(&points, &testrect)); + CATCH(errctx, akgl_rectangle_points(&points, &testrect)); if ( points.topleft.x != 0 || points.topleft.y != 0 || points.topright.x != 32 || @@ -64,7 +64,7 @@ akerr_ErrorContext *test_rectangle_points_math(void) FAIL_BREAK( errctx, AKERR_BEHAVIOR, - "rectangle_points incorrectly calculated points for {x=0, y=0, w=32, h=32} to {topleft={%d, %d}, topright={%d, %d}, bottomleft={%d, %d}, bottomright={%d, %d}}", + "akgl_rectangle_points incorrectly calculated points for {x=0, y=0, w=32, h=32} to {topleft={%d, %d}, topright={%d, %d}, bottomleft={%d, %d}, bottomright={%d, %d}}", points.topleft.x, points.topleft.y, points.topright.x, points.topright.y, points.bottomleft.x, points.bottomleft.y, @@ -77,7 +77,7 @@ akerr_ErrorContext *test_rectangle_points_math(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) +akerr_ErrorContext *test_akgl_collide_point_rectangle_nullpointers(void) { point testpoint; RectanglePoints testrectpoints; @@ -86,8 +86,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, NULL)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(*, *, NULL) failed"); + CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, NULL)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(*, *, NULL) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -95,8 +95,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_point_rectangle(&testpoint, NULL, &testcollide)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(*, NULL, *) failed"); + CATCH(errctx, akgl_collide_point_rectangle(&testpoint, NULL, &testcollide)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(*, NULL, *) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -104,8 +104,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_point_rectangle(NULL, &testrectpoints, &testcollide)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(NULL, *, *) failed"); + CATCH(errctx, akgl_collide_point_rectangle(NULL, &testrectpoints, &testcollide)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(NULL, *, *) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -113,8 +113,8 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_point_rectangle(NULL, NULL, NULL)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_point_rectangle(NULL, NULL, NULL) failed"); + CATCH(errctx, akgl_collide_point_rectangle(NULL, NULL, NULL)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_point_rectangle(NULL, NULL, NULL) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -122,7 +122,7 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, &testcollide)); + CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide)); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); @@ -130,7 +130,7 @@ akerr_ErrorContext *test_collide_point_rectangle_nullpointers(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_collide_point_rectangle_logic(void) +akerr_ErrorContext *test_akgl_collide_point_rectangle_logic(void) { point testpoint = {.x = 16, .y = 16}; SDL_FRect testrect = { .x = 0, .y = 0, .w = 32, .h = 32}; @@ -139,15 +139,15 @@ akerr_ErrorContext *test_collide_point_rectangle_logic(void) PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, rectangle_points(&testrectpoints, &testrect)); - CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, &testcollide)); + CATCH(errctx, akgl_rectangle_points(&testrectpoints, &testrect)); + CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } testpoint.x = 48; testpoint.y = 48; - CATCH(errctx, collide_point_rectangle(&testpoint, &testrectpoints, &testcollide)); + CATCH(errctx, akgl_collide_point_rectangle(&testpoint, &testrectpoints, &testcollide)); if ( testcollide == true ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Invalid collision reported"); } @@ -157,7 +157,7 @@ akerr_ErrorContext *test_collide_point_rectangle_logic(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_collide_rectangles_nullpointers(void) +akerr_ErrorContext *test_akgl_collide_rectangles_nullpointers(void) { SDL_FRect testrect1; SDL_FRect testrect2; @@ -166,8 +166,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void) PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, NULL)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(*, *, NULL) failed"); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, NULL)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(*, *, NULL) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -175,8 +175,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_rectangles(&testrect1, NULL, &testcollide)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(*, NULL, *) failed"); + CATCH(errctx, akgl_collide_rectangles(&testrect1, NULL, &testcollide)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(*, NULL, *) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -184,8 +184,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_rectangles(NULL, &testrect2, &testcollide)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(NULL, *, *) failed"); + CATCH(errctx, akgl_collide_rectangles(NULL, &testrect2, &testcollide)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(NULL, *, *) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -193,8 +193,8 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_rectangles(NULL, NULL, NULL)); - FAIL_BREAK(errctx, AKERR_BEHAVIOR, "collide_rectangles(NULL, NULL, NULL) failed"); + CATCH(errctx, akgl_collide_rectangles(NULL, NULL, NULL)); + FAIL_BREAK(errctx, AKERR_BEHAVIOR, "akgl_collide_rectangles(NULL, NULL, NULL) failed"); } CLEANUP { } PROCESS(errctx) { } HANDLE(errctx, AKERR_NULLPOINTER) { @@ -202,7 +202,7 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void) } FINISH(errctx, true); ATTEMPT { - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); } CLEANUP { } PROCESS(errctx) { } FINISH(errctx, true); @@ -210,7 +210,7 @@ akerr_ErrorContext *test_collide_rectangles_nullpointers(void) SUCCEED_RETURN(errctx); } -akerr_ErrorContext *test_collide_rectangles_logic(void) +akerr_ErrorContext *test_akgl_collide_rectangles_logic(void) { SDL_FRect testrect1 = { .x = 0, .y = 0, .w = 32, .h = 32}; SDL_FRect testrect2 = { .x = 30, .y = 30, .w = 40, .h = 40}; @@ -220,14 +220,14 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) ATTEMPT { // Collision overlapping on the top left - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } // Collision overlapping on the top right testrect1.x = 64; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -235,7 +235,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) // Collision overlapping on the bottom left testrect1.x = 0; testrect1.y = 32; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -243,7 +243,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) // Collision overlapping on the bottom right testrect1.x = 32; testrect1.y = 32; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -253,7 +253,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) testrect1.y = 0; testrect1.w = 60; testrect1.h = 32; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -263,7 +263,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) testrect1.y = 0; testrect1.w = 35; testrect1.h = 80; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -273,7 +273,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) testrect1.y = 0; testrect1.w = 60; testrect1.h = 80; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -283,7 +283,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) testrect1.y = 65; testrect1.w = 80; testrect1.h = 32; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == false ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Valid collision missed"); } @@ -293,7 +293,7 @@ akerr_ErrorContext *test_collide_rectangles_logic(void) testrect1.y = 0; testrect1.w = 16; testrect1.h = 16; - CATCH(errctx, collide_rectangles(&testrect1, &testrect2, &testcollide)); + CATCH(errctx, akgl_collide_rectangles(&testrect1, &testrect2, &testcollide)); if ( testcollide == true ) { FAIL_BREAK(errctx, AKERR_BEHAVIOR, "Invalid collision reported"); } @@ -309,11 +309,11 @@ int main(void) { PREPARE_ERROR(errctx); ATTEMPT { - CATCH(errctx, test_rectangle_points_nullpointers()); - CATCH(errctx, test_rectangle_points_math()); - CATCH(errctx, test_collide_point_rectangle_nullpointers()); - CATCH(errctx, test_collide_rectangles_nullpointers()); - CATCH(errctx, test_collide_rectangles_logic()); + CATCH(errctx, test_akgl_rectangle_points_nullpointers()); + CATCH(errctx, test_akgl_rectangle_points_math()); + CATCH(errctx, test_akgl_collide_point_rectangle_nullpointers()); + CATCH(errctx, test_akgl_collide_rectangles_nullpointers()); + CATCH(errctx, test_akgl_collide_rectangles_logic()); } CLEANUP { } PROCESS(errctx) { } FINISH_NORETURN(errctx); diff --git a/util/charviewer.c b/util/charviewer.c index 5108063..ab07f11 100644 --- a/util/charviewer.c +++ b/util/charviewer.c @@ -23,7 +23,7 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) { PREPARE_ERROR(errctx); - actor *actorptr = NULL; + akgl_Actor *actorptr = NULL; int i = 0; int gamepadids[32]; char *characterjson = NULL; @@ -51,9 +51,9 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) game.screenwidth = 640; game.screenheight = 480; - CATCH(errctx, GAME_init()); - CATCH(errctx, heap_init()); - CATCH(errctx, registry_init()); + CATCH(errctx, akgl_game_init()); + CATCH(errctx, akgl_heap_init()); + CATCH(errctx, akgl_registry_init()); } CLEANUP { } PROCESS(errctx) { @@ -70,7 +70,7 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) sprintf((char *)&pathbuf, "%s", argv[i]); } SDL_Log("Loading sprite %s...", (char *)&pathbuf); - CATCH(errctx, sprite_load_json((char *)&pathbuf)); + CATCH(errctx, akgl_sprite_load_json((char *)&pathbuf)); } CLEANUP { } PROCESS(errctx) { } HANDLE_DEFAULT(errctx) { @@ -87,25 +87,25 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[]) sprintf((char *)&pathbuf, "%s", characterjson); } SDL_Log("Loading character %s...", (char *)&pathbuf); - CATCH(errctx, character_load_json((char *)&pathbuf)); - CATCH(errctx, heap_next_actor(&actorptr)); - CATCH(errctx, actor_initialize((actor *)actorptr, "player")); + CATCH(errctx, akgl_character_load_json((char *)&pathbuf)); + CATCH(errctx, akgl_heap_next_actor(&actorptr)); + CATCH(errctx, akgl_actor_initialize((akgl_Actor *)actorptr, "player")); actorptr->basechar = SDL_GetPointerProperty( - REGISTRY_CHARACTER, + AKGL_REGISTRY_CHARACTER, "little guy", NULL); FAIL_ZERO_BREAK(errctx, actorptr->basechar, AKERR_REGISTRY, "Can't load character 'little guy' from the registry"); actorptr->movement_controls_face = false; - actorptr->state = (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_DOWN); + actorptr->state = (AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_DOWN); actorptr->x = 320; actorptr->y = 240; actorptr->visible = true; // Open the first gamepad - FAIL_ZERO_BREAK(errctx, SDL_GetGamepads((int *)&gamepadids), AKERR_SDL, "%s", SDL_GetError()); + FAIL_ZERO_BREAK(errctx, SDL_GetGamepads((int *)&gamepadids), AKGL_ERR_SDL, "%s", SDL_GetError()); SDL_Log("Opening gamepad %d", gamepadids[0]); - FAIL_ZERO_BREAK(errctx, SDL_OpenGamepad(gamepadids[0]), AKERR_SDL, "%s", SDL_GetError()); - CATCH(errctx, SDL3G_controller_default(0, "player", 0, gamepadids[0])); + FAIL_ZERO_BREAK(errctx, SDL_OpenGamepad(gamepadids[0]), AKGL_ERR_SDL, "%s", SDL_GetError()); + CATCH(errctx, akgl_controller_default(0, "player", 0, gamepadids[0])); } CLEANUP { } PROCESS(errctx) { @@ -125,7 +125,7 @@ SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) FAIL_ZERO_BREAK(errctx, appstate, AKERR_NULLPOINTER, "NULL appstate pointer"); FAIL_ZERO_BREAK(errctx, event, AKERR_NULLPOINTER, "NULL event pointer"); - CATCH(errctx, controller_handle_event(appstate, event)); + CATCH(errctx, akgl_controller_handle_event(appstate, event)); if (event->type == SDL_EVENT_QUIT) { return SDL_APP_SUCCESS; /* end the program, reporting success to the OS. */ } @@ -138,17 +138,17 @@ SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event) SDL_AppResult SDL_AppIterate(void *appstate) { int i = 0; - iterator opflags; + akgl_Iterator opflags; PREPARE_ERROR(errctx); - BITMASK_CLEAR(opflags.flags); - BITMASK_ADD(opflags.flags, ITERATOR_OP_UPDATE); - BITMASK_ADD(opflags.flags, ITERATOR_OP_RENDER); - GAME_draw_background(game.screenwidth, game.screenheight); + AKGL_BITMASK_CLEAR(opflags.flags); + AKGL_BITMASK_ADD(opflags.flags, AKGL_ITERATOR_OP_UPDATE); + AKGL_BITMASK_ADD(opflags.flags, AKGL_ITERATOR_OP_RENDER); + akgl_draw_background(game.screenwidth, game.screenheight); ATTEMPT { - CATCH(errctx, tilemap_draw(renderer, (tilemap *)&gamemap, &camera, i)); - SDL_EnumerateProperties(REGISTRY_ACTOR, ®istry_iterate_actor, (void *)&opflags); + CATCH(errctx, akgl_tilemap_draw(renderer, (tilemap *)&gamemap, &camera, i)); + SDL_EnumerateProperties(AKGL_REGISTRY_ACTOR, &akgl_registry_iterate_actor, (void *)&opflags); } CLEANUP { } PROCESS(errctx) { } HANDLE_DEFAULT(errctx) {