Add state for persistent data beyond just the world

include/keraforge.h

···
 #include <keraforge/input.h>
 #include <keraforge/math.h>
 #include <keraforge/sprites.h>
+#include <keraforge/state.h>
 #include <keraforge/ui.h>
 #include <keraforge/world.h>
 

include/keraforge/state.h

···
+#ifndef __kf_state__
+#define __kf_state__
+
+
+#include <keraforge/actor.h>
+
+
+#define KF_NPCPOOL_SIZE 1024
+
+
+/* Stores global variables to be saved alongside the world. Use this for save data.
+   Do not use pointers here! This gets transmuted into a u8 array for serialization. */
+struct kf_state
+{
+	/* Do not modify this and do not relocate it. See kf_world for an explanation. */
+	u16 revision;
+	/* Player data */
+	struct {
+		struct kf_vec2(f32) pos;
+	} player;
+	// struct kf_actor npc[KF_NPCPOOL_SIZE];
+};
+
+
+/* Save a state. */
+int kf_state_save(struct kf_state *state);
+/* Load a state. Returns 1 if the state was freshly created and 0 if an existing state was loaded. */
+int kf_state_load(struct kf_state **pstate);
+
+
+#endif

src/main.c

···
+#include "keraforge/world.h"
 #include <keraforge.h>
 #include <raylib.h>
 #include <raymath.h>
···
 } modal;
 static char *modals[] = { "play", "edit" };
 static bool dirty = false;
-static bool preserve_mapdotbin = false;
 
 static kf_inputbind_t
 	inputbind_move_up,
···
 
 
 static
-void loadbinds()
+void loadbinds(void)
 {
 	inputbind_move_up    = kf_addinput("move_up",    KEY_W,          KEY_NULL,   MOUSE_BUTTON_UNKNOWN, GAMEPAD_BUTTON_UNKNOWN,          GAMEPAD_AXIS_LEFT_Y);
 	inputbind_move_down  = kf_addinput("move_down",  KEY_S,          KEY_NULL,   MOUSE_BUTTON_UNKNOWN, GAMEPAD_BUTTON_UNKNOWN,          GAMEPAD_AXIS_LEFT_Y);
···
 
 	inputbind_toggle_fps_limit = kf_addinput("toggle_fps_limit", KEY_NINE, KEY_NULL, MOUSE_BUTTON_UNKNOWN, GAMEPAD_BUTTON_UNKNOWN, GAMEPAD_AXIS_UNKNOWN);
 	inputbind_toggle_editor = kf_addinput("toggle_editor", KEY_EIGHT, KEY_NULL, MOUSE_BUTTON_UNKNOWN, GAMEPAD_BUTTON_UNKNOWN, GAMEPAD_AXIS_UNKNOWN);
+}
+
+static
+void loadtiles(struct kf_spritesheet *terrain)
+{
+	KF_ADDTILE(
+		.key = "grass",
+		.mapcol = GREEN,
+		.sheet = terrain,
+		.sprite = {0, 0},
+	);
+	KF_ADDTILE(
+		.key = "sand",
+		.mapcol = YELLOW,
+		.sheet = terrain,
+		.sprite = {4, 0},
+	);
+	KF_ADDTILE(
+		.key = "stone",
+		.mapcol = GRAY,
+		.sheet = terrain,
+		.sprite = {0, 4},
+	);
+	KF_ADDTILE(
+		.key = "debug",
+		.mapcol = BLUE,
+		.sheet = terrain,
+		.sprite = {4, 4},
+	);
+	KF_ADDTILE(
+		.key = "brick",
+		.mapcol = RED,
+		.sheet = terrain,
+		.sprite = {8, 0},
+		.collide = true,
+	);
+	KF_ADDTILE(
+		.key = "ice",
+		.mapcol = BLUE,
+		.sheet = terrain,
+		.sprite = {8, 4},
+		.transparent = true,
+	);
+	KF_ADDTILE(
+		.key = "dirt",
+		.mapcol = BROWN,
+		.sheet = terrain,
+		.sprite = {12, 0},
+	);
+	KF_ADDTILE(
+		.key = "torch",
+		.mapcol = ORANGE,
+		.sheet = terrain,
+		.sprite = {12, 4},
+		.transparent = true,
+	);
+	kf_logdbg("loaded %d tiles", kf_tiles.count);
 }
 
 static
···
 	loadbinds();
 
 	struct kf_spritesheet terrain = kf_loadspritesheet("data/res/img/tile/terrain.png", 16, 16);
-	KF_ADDTILE(
-		.key = "grass",
-		.mapcol = GREEN,
-		.sheet = &terrain,
-		.sprite = {0, 0},
-	);
-	KF_ADDTILE(
-		.key = "sand",
-		.mapcol = YELLOW,
-		.sheet = &terrain,
-		.sprite = {4, 0},
-	);
-	KF_ADDTILE(
-		.key = "stone",
-		.mapcol = GRAY,
-		.sheet = &terrain,
-		.sprite = {0, 4},
-	);
-	KF_ADDTILE(
-		.key = "debug",
-		.mapcol = BLUE,
-		.sheet = &terrain,
-		.sprite = {4, 4},
-	);
-	KF_ADDTILE(
-		.key = "brick",
-		.mapcol = RED,
-		.sheet = &terrain,
-		.sprite = {8, 0},
-		.collide = true,
-	);
-	KF_ADDTILE(
-		.key = "ice",
-		.mapcol = BLUE,
-		.sheet = &terrain,
-		.sprite = {8, 4},
-		.transparent = true,
-	);
-	KF_ADDTILE(
-		.key = "dirt",
-		.mapcol = BROWN,
-		.sheet = &terrain,
-		.sprite = {12, 0},
-	);
-	kf_logdbg("loaded %d tiles", kf_tiles.count);
+	loadtiles(&terrain);
 
 	struct kf_uiconfig *uiconfig = kf_ui_getconfig();
 	uiconfig->select = inputbind_select;
···
 	if (!DirectoryExists("data"))
 		MakeDirectory("data");
 
+	struct kf_state *state = NULL;
+	int is_new_state = kf_state_load(&state);
+
 	struct kf_world *world = NULL;
 	kf_world_load(&world, true);
 	if (!world)
-		KF_THROW("failed to load world: %p", world);
+		KF_THROW("failed to load world");
 
 	struct kf_actor *player = kf_actor_new(kf_actor_loadspritesheet("data/res/img/char/template.png"), 10, 10, true);
 	player->sizeoffset.y = 6;
-	player->pos.x = world->width / 4.0f * KF_TILE_SIZE_PX;
-	player->pos.y = world->height / 4.0f * KF_TILE_SIZE_PX;
 	player->tick = _player_tick;
 	player->draw = _player_draw;
 	player->controlled = true;
+	if (is_new_state)
+	{
+		state->player.pos.x = world->width * KF_TILE_SIZE_PX / 2.0f;
+		state->player.pos.y = world->width * KF_TILE_SIZE_PX / 2.0f;
+	}
+	player->pos.x = state->player.pos.x;
+	player->pos.y = state->player.pos.y;
+	kf_loginfo("pos: %f,%f", player->pos.x, player->pos.y);
 
 	cam = (Camera2D){0};
 	cam.offset.x = GetScreenWidth() / 2.0f;
 	cam.offset.y = GetScreenHeight() / 2.0f;
+	cam.target.x = player->pos.x + (player->size.x / 2);
+	cam.target.y = player->pos.y + (player->size.y / 2);
 	cam.zoom = 2;
 
 	int running = 1;
···
 		kf_s += kf_dts;
 	}
 
-	if (world)
-	{
-		if (dirty)
-		{
-			if (!kf_writebin("data/tmp/map.bin", (u8 *)world, kf_world_getsize(world)))
-				KF_THROW("failed to save map.bin");
-			if (!kf_compress("data/tmp/map.bin", "data/map.bin.xz"))
-				KF_THROW("failed to compress map.bin into map.bin.xz");
-			if (!preserve_mapdotbin)
-				remove("data/tmp/map.bin");
-		}
-		free(world);
-	}
+	state->player.pos = player->pos;
+	kf_state_save(state);
+	free(state);
+
+	if (dirty)
+		kf_world_save(world, true);
+	free(world);
+
 	CloseWindow();
 
 	return 0;

src/state.c

···
+#include <keraforge.h>
+
+
+#define _KF_STATEFILE "data/state.bin"
+
+int kf_state_save(struct kf_state *state)
+{
+	if (!kf_writebin(_KF_STATEFILE, (u8 *)state, sizeof(*state)))
+	{
+		KF_THROW("failed to write to %s", _KF_STATEFILE);
+		return 0; /* unreachable */
+	}
+
+	return 1;
+}
+
+int kf_state_load(struct kf_state **pstate)
+{
+	char *infile = _KF_STATEFILE;
+	kf_logdbg("loading state: %s", infile);
+
+	int res = 0;
+
+	if (!kf_exists(infile))
+	{
+		kf_logdbg("creating state...");
+		struct kf_state s = {0};
+		kf_state_save(&s);
+		res = 1;
+	}
+
+	size_t len = 0;
+	*pstate = (struct kf_state *)kf_readbin(infile, &len);
+	kf_logdbg("loaded state (%p): len=%lu (res=%d)", *pstate, len, res);
+
+	if (!*pstate)
+	{
+		KF_THROW("failed to load state");
+		return -1; /* unreachable */
+	}
+
+	return res;
+}

src/world.c

···
 {
 	const size_t len = sizeof(struct kf_world) + sizeof(struct kf_tile)*width*height;
 	struct kf_world *world = malloc(len);
-	kf_loginfo("creating world: %lu bytes: %p\n", len, world);
+	kf_loginfo("creating world: %lu bytes: %p", len, world);
 	world->revision = 0;
 	world->width = width;
 	world->height = height;
···
 
 			tile++; /* shift tile pointer to the right */
 		}
+
 		tile += down; /* shift tile pointer down */
 	}
 }
···
 
 	size_t len = 0;
 	*pworld = (struct kf_world *)kf_readbin(infile, &len);
-	kf_logdbg("loaded world (%p): r=%d, wh=%dx%d, len=%lu", pworld, (*pworld)->revision, (*pworld)->width, (*pworld)->height, len);
+	kf_logdbg("loaded world (%p): r=%d, wh=%dx%d, len=%lu", *pworld, (*pworld)->revision, (*pworld)->width, (*pworld)->height, len);
 
 	if (compressed)
 	{
···
 		remove(_KF_MAPFILE_TMP);
 	}
 
-	if (!pworld)
+	if (!*pworld)
 	{
 		KF_THROW("failed to load world");
 		return 0; /* unreachable */

todo

···
 
 . Core
   . World
-    / Tiles
+    x Tiles
     . Actors
     x Compression
       . Compress without saving the world binary as an intermediate step.