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

Unify the library on an akgl_ namespace

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

12
include/controller.h
View File

@@ -1,12 +0,0 @@
#ifndef _GAMEPAD_H_
#define _GAMEPAD_H_
#include <SDL3/SDL.h>
#include <akerror.h>
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_

4
include/sdl3game/SDL_GameControllerDB.h
View File

@@ -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",

143
include/sdl3game/actor.h
View File

@@ -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_

2
include/sdl3game/assets.h
View File

@@ -3,6 +3,6 @@
#include <akerror.h>
akerr_ErrorContext AKERR_NOIGNORE *load_start_bgm(char *fname);
akerr_ErrorContext AKERR_NOIGNORE *akgl_load_start_bgm(char *fname);
#endif //_ASSETS_H_

30
include/sdl3game/character.h
View File

@@ -1,31 +1,31 @@
#ifndef _CHARACTER_H_
#define _CHARACTER_H_
#ifndef _AKGL_CHARACTER_H_
#define _AKGL_CHARACTER_H_
#include <SDL3/SDL_properties.h>
#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_

32
include/sdl3game/controller.h
View File

@@ -4,8 +4,8 @@
#include <SDL3/SDL.h>
#include <akerror.h>
#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_

2
include/sdl3game/draw.h
View File

@@ -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_

2
include/sdl3game/error.h
View File

@@ -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_

40
include/sdl3game/game.h
View File

@@ -1,14 +1,14 @@
#ifndef _GAME_H_
#define _GAME_H_
#ifndef _AKGL_GAME_H_
#define _AKGL_GAME_H_
#include <SDL3_mixer/SDL_mixer.h>
#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_

48
include/sdl3game/heap.h
View File

@@ -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 <akerror.h>
#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_

72
include/sdl3game/iterator.h
View File

@@ -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_

18
include/sdl3game/json_helpers.h
View File

@@ -4,14 +4,14 @@
#include <akerror.h>
#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_

30
include/sdl3game/registry.h
View File

@@ -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_

36
include/sdl3game/sprite.h
View File

@@ -1,44 +1,44 @@
#ifndef _SPRITE_H_
#define _SPRITE_H_
#ifndef _AKGL_SPRITE_H_
#define _AKGL_SPRITE_H_
#include <SDL3/SDL_properties.h>
#include <SDL3/SDL.h>
#include <akerror.h>
#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_

8
include/sdl3game/staticstring.h
View File

@@ -4,14 +4,14 @@
#include "string.h"
#include <akerror.h>
#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_

4
include/sdl3game/text.h
View File

@@ -3,7 +3,7 @@
#include <SDL3_ttf/SDL_ttf.h>
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_

78
include/sdl3game/tilemap.h
View File

@@ -5,20 +5,20 @@
#include "staticstring.h"
#include <jansson.h>
#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_

12
include/sdl3game/util.h
View File

@@ -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_

2
mkcontrollermappings.sh
View File

@@ -10,7 +10,7 @@ cat > ../include/sdl3game/SDL_GameControllerDB.h <<EOF
// Taken from https://raw.githubusercontent.com/mdqinc/SDL_GameControllerDB/refs/heads/master/gamecontrollerdb.txt on $(date)
#define SDL_GAMECONTROLLER_DB_LEN ${filelen}
#define AKGL_SDL_GAMECONTROLLER_DB_LEN ${filelen}
const char *SDL_GAMECONTROLLER_DB[] = {
EOF

10
sdl3game.pc.in Normal file
View File

@@ -0,0 +1,10 @@
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${exec_prefix}/include
Name: sdl3game
Description: AKLabs SDL3 Game library
Version: @PROJECT_VERSION@
Cflags: -I${includedir}/
Libs: -L${libdir} -lsdl3game

134
src/actor.c
View File

@@ -11,27 +11,27 @@
#include <sdl3game/staticstring.h>
#include <sdl3game/iterator.h>
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);
}

66
src/actor_state_string_names.c
View File

@@ -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",
};

20
src/assets.c
View File

@@ -7,19 +7,19 @@
#include <sdl3game/heap.h>
#include <sdl3game/error.h>
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);

110
src/character.c
View File

@@ -13,29 +13,29 @@
#include <sdl3game/iterator.h>
#include <sdl3game/util.h>
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) {

126
src/controller.c
View File

@@ -5,26 +5,26 @@
#include <sdl3game/game.h>
#include <sdl3game/controller.h>
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);

2
src/draw.c
View File

@@ -4,7 +4,7 @@
#include <sdl3game/game.h>
/* 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 },

52
src/game.c
View File

@@ -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;

92
src/heap.c
View File

@@ -9,39 +9,39 @@
#include <sdl3game/iterator.h>
#include <sdl3game/error.h>
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);
}

30
src/json_helpers.c
View File

@@ -8,7 +8,7 @@
#include <sdl3game/staticstring.h>
#include <sdl3game/registry.h>
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);
}

78
src/registry.c
View File

@@ -6,92 +6,92 @@
#include <sdl3game/iterator.h>
#include <sdl3game/actor.h>
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);
}

116
src/sprite.c
View File

@@ -13,72 +13,72 @@
#include <sdl3game/staticstring.h>
#include <sdl3game/iterator.h>
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);

6
src/staticstring.c
View File

@@ -1,14 +1,14 @@
#include <akerror.h>
#include <sdl3game/staticstring.h>
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);

60
src/text.c Normal file
View File

@@ -0,0 +1,60 @@
#include <akerror.h>
#include <SDL3/SDL.h>
#include <SDL3_ttf/SDL_ttf.h>
#include <sdl3game/text.h>
#include <sdl3game/registry.h>
#include <sdl3game/game.h>
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);
}

218
src/tilemap.c
View File

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

48
src/util.c
View File

@@ -10,7 +10,7 @@
#include <sdl3game/registry.h>
#include <sdl3game/game.h>
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);

146
tests/actor.c
View File

@@ -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) {

4
tests/assets/testcharacter.json
View File

@@ -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"
},

30
tests/bitmasks.c
View File

@@ -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;
}

134
tests/character.c
View File

@@ -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);

56
tests/charviewer.c
View File

@@ -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 {

14
tests/registry.c
View File

@@ -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(&registry_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(&registry_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(&registry_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(&registry_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);

108
tests/sprite.c
View File

@@ -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);

62
tests/staticstring.c
View File

@@ -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 *)&copybuf, 'a', MAX_STRING_LENGTH);
char copybuf[AKGL_MAX_STRING_LENGTH];
akgl_String *ptr;
memset((void *)&copybuf, '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 *)&copybuf, 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 *)&copybuf, 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);

158
tests/tilemap.c
View File

@@ -11,28 +11,28 @@
#include <sdl3game/game.h>
#include <sdl3game/json_helpers.h>
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);

100
tests/util.c
View File

@@ -2,15 +2,15 @@
#include <akerror.h>
#include <sdl3game/util.h>
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);

42
util/charviewer.c
View File

@@ -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, &registry_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) {