How do I initialize a game

Initialize the global game object with info about your game

	strncpy((char *)&game.name, "sdl3-gametest", 256);
	strncpy((char *)&game.version, "0.0.1", 32);
	strncpy((char *)&game.uri, "net.aklabs.games.sdl3-gametest", 256);

Call the game initialization routines and lock the game state for further initialization

PASS(e, akgl_game_init());
PASS(e, akgl_game_state_lock());

If you have a registry properties file, load it. If you don't have a properties file, use akgl_set_property("prop_name", "prop_value") to populate the required game properties.

PASS(e, akgl_registry_load_properties(YOUR_REGISTR_FILEPATH));

Initialize your physics engine and renderer of choice

PASS(e, akgl_render_init2d(renderer));
PASS(e, akgl_physics_init_arcade(physics));

Unlock the game state

PASS(e, akgl_game_state_unlock());

What is in a properties file (or, What properties must I set if I don't have one?)

{
    "properties": {
		"game.screenwidth": "640",
		"game.screenheight": "480",
		"physics.gravity.y": "1024.0",
		"physics.drag.y": "1.0"
    }
}

Physics properties (gravity and drag along X, Y and Z) are optional and default to 0.

How do I update and render the game world in my main loop

In your game loop (or in your SDL_AppIterate method), lock the game state, call the renderer to draw the world within the visible camera, and then unlock the game state

PASS(e, akgl_game_state_lock());
PASS(e, renderer->frame_start(renderer));
SDL_RenderClear(renderer->sdl_renderer);
PASS(e, akgl_game_update(NULL));
PASS(e, renderer->frame_end(renderer));
PASS(e, akgl_game_state_unlock());

How do I get an actor on screen

Load a sprite for a character. Sprites are JSON documents describing 2D sprites, frames, and looping. Sprites are named, and sprite names must be unique.

PASS(e, akgl_sprite_load_json(SOME_FILENAME))

Load a character from a JSON file. Characters map sprites to actor states and define physics characteristics like movement speed. Each character is named, and character names must be unique.

PASS(e, akgl_character_load_json(SOME_FILENAME))

Initialize an actor. Actors are named ("player", "Quest NPC", whatever) and names must be unique.

akgl_Actor *myactor = NULL;
PASS(e, akgl_heap_next_actor(&myactor);
PASS(e, akgl_actor_initialize(&myactor, "ACTOR_NAME"));

Assign a character to the actor by looking up the akgl_Character from the AKGL registry and assign it.

myactor->basechar = SDL_GetPointerProperty(
    AKGL_REGISTRY_CHARACTER,
	"CHARACTER_NAME",
	NULL);
FAIL_ZERO_BREAK(e, myactor->basechar, AKERR_REGISTRY, "Character missing");

Give the actor a position and a state, and turn it visible.

myactor->state = 9AKGL_ACTOR_STATE_ALIVE | AKGL_ACTOR_STATE_FACE_LEFT);
myactor->x = 320;
myactor->y = 240;
myactor->visible = true;

What are in Sprite and Character files

Sprite files:

{
    "spritesheet": {
    	"filename": "RELATIVE_IMAGE_FILE_REFERENCE",
	    "frame_width": int,
	    "frame_height": int
    },
    "name": "UNIQUE_SPRITE_NAME",
    "width": int,
    "height": int,
    "speed": int,
    "loop": boolean,
    "loopReverse": boolean,
    "frames": [
	    int
    ]
}

• frames references the frame indexes in the spritesheet that should be used for this animation. Spritesheets are counted from the top left corner going to the right according to the spritesheet frame_width and frame_height.
• loop says whether or not we should loop the animation
• loopReverse says whether or not we should "bounce" the animation (when we reach the end of the frames, start counting back to the beginning, then count to the end, etc). Otherwise the frames are displayed from 0..n and then cycles back to 0.
• speed is the number of milliseconds each frame in the animation should appear on the screen

Character files:

{
    "name": "UNIQUE_CHARACTER_NAME",
    "speedtime": 8,
    "speed_x": 0,
    "speed_y": 0,
    "acceleration_x": 0,
    "acceleration_y": 0,
    "sprite_mappings": [
		{
			"state": [
				"AKGL_ACTOR_STATE_ALIVE",
				"AKGL_ACTOR_STATE_FACE_UP",
				"AKGL_ACTOR_STATE_MOVING_UP"		
			],		
			"sprite": "menupointer"
		}[, ...]
    ]
}

• speedtime appears to be legacy and unused.
• speed_[xy] and acceleration_[xy] are physics parameters that specify the top speed and acceleration rate (in pixels per nanosecond) of the character in physics simulations. The effect of acceleration depends on the physics simulation being used at the time (which may or may not account for gravity, drag, etc).
• sprite_mappings map a set of actor state flag bitmasks (assume everything in state is ORed together) to a sprite name. The game engine uses this to automatically pick the correct sprite (by name) for a given set of state flags. You need one of these for every possible state the character may be used in.

How do I load a tilemap from the filesystem and display it on screen with my actors

The engine ONLY supports TilED TMJ tilemaps with tileset external references. Load a tilemap into the global akgl_Tilemap *gamemap object.

PASS(e, akgl_tilemap_load(PATHSTRING, gamemap));

Actors will be automatically populated from objects in the tilemap object layers. Actor state flags here must be expressed as an integer, you can't (yet) use the same array of strings that is used in character json files.

         "objects":[
                {
                 "gid":147,
                 "height":16,
                 "id":1,
                 "name":"player",
                 "properties":[
                        {
                         "name":"character",
                         "type":"string",
                         "value":"little guy"
                        }, 
                        {
                         "name":"state",
                         "type":"int",
                         "value":24
                        }],
                 "rotation":0,
                 "type":"actor",
                 "visible":true,
                 "width":16,
                 "x":440.510088317656,
                 "y":140.347239175702
                }[, ... ] 

Check if the tilemap wants to use its own physics, and if you want to allow that, override the global physics simulation

if ( gamemap->use_own_physics == true ) {
	physics = &gamemap->physics;
}

Tilemap physics specification follows. A map can specify its own physics properties (drag, gravity) without specifying a custom model.

 "properties":[
        {
         "name":"physics.drag.y",
         "type":"float",
         "value":0
        }, 
        {
         "name":"physics.gravity.y",
         "type":"float",
         "value":0
        }, 
        {
         "name":"physics.model",
         "type":"string",
         "value":"arcade"
        }],

The global gamemap object is automatically displayed if it is populated. Actors are drawn at the appropriate map layer depending on the actor's layer property (warning: this may be replaced with a z property soon.)

How do I get the screen width and height

The most direct is to call SDL_GetCurrentDisplayMode to get the parameters from the returned SDL_DisplayMode structure (->w and ->h).

The simplest way is to check the global camera object's camera->w and camera->h object. You may have more than one camera on a scene, and it's theoretically possible that the global camera object has been overriden and no longer represents the full screen.

The most reliable engine-centric way is to use akgl_get_property to get the property from the engine. Properties are read and stored as strings, so if you need to do these kinds of things a lot, cache the integer value somewhere.

akgl_String *width = NULL;
int screenwidth = NULL;
PASS(e, akgl_get_property("game.screenwidth", &width, "0"));
PASS(e, aksl_atoi(width->data, &screenwidth));
PASS(e, akgl_heap_release_string(width));