Finally finish actor (de)serialization!

include/keraforge.h

···
 #include <keraforge/player.h>
 #include <keraforge/sprites.h>
 #include <keraforge/state.h>
+#include <keraforge/string.h>
 #include <keraforge/time.h>
 #include <keraforge/ui.h>
 #include <keraforge/world.h>

include/keraforge/actor.h

···
 /* Represents any kinematic body in the world (players, NPCs, etc). */
 struct kf_actor
 {
-	/* Unique string identifier for this actor. */
-	char *key;
-	/* Unique integer identifier for this actor, comes from kf_actorregistry. */
+	/* Integer identifier for this actor, comes from kf_actorregistry. */
 	int id;
 	/* The actor's position. */
 	struct kf_vec2(f32) pos;

include/keraforge/state.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. */
+/* Stores global variables to be saved alongside the world. Use this for save data. */
 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];
 };
 
 

include/keraforge/string.h

···
+#ifndef __kf_string__
+#define __kf_string__
+
+
+#include <keraforge/_header.h>
+
+
+char *kf_strdup(char *str);
+
+
+#endif

src/actor.c

···
 	}
 
 	actor->id = kf_actor_getregistryid(key);
-	actor->key = key;
 	actor->size.x = 10;
 	actor->size.y = 10;
 	actor->collide = true;
···
 
 int kf_saveactors(void)
 {
-	size_t nactors = 0;
-
 	struct bini_stream *bs = bini_new();
 
 	/* kf_actor_count includes unserialized actors, so we have to manually count. */
+	size_t nactors = 0;
 	for (struct kf_actor *actor = kf_actors ; actor != NULL ; actor = actor->next)
 	{
-		if (!actor->key)
-			continue;
-		int id = kf_actor_getregistryid(actor->key);
-		if (id == -1)
+		if (actor->id == -1)
 			continue;
 		nactors++;
 	}
 	bini_wlu(bs, nactors);
+	kf_logdbg("expecting to save %lu actors", nactors);
 
 	for (struct kf_actor *actor = kf_actors ; actor != NULL ; actor = actor->next)
 	{
-		if (!actor->key)
-			continue;
-		int id = kf_actor_getregistryid(actor->key);
-		if (id == -1)
+		if (actor->id == -1)
 			continue;
-		bini_wstr(bs, actor->key);
-		kf_actorregistry.serialize[id](actor, bs);
+		bini_wstr(bs, kf_actorregistry.key[actor->id]);
+		kf_actorregistry.serialize[actor->id](actor, bs);
 	}
 
 	kf_logdbg("serialized %d actors (%lu bytes)", nactors, bs->len);
···
 	// char *infile = compress ? _KF_ACTORFILE_TMP : _KF_ACTORFILE;
 	char *infile = _KF_ACTORFILE;
 
+	if (!kf_exists(infile))
+	{
+		kf_logdbg("actors.bin nonexistent, creating...");
+		kf_saveactors();
+		return 1;
+	}
+
 	size_t len = 0;
 	struct bini_stream bs = {
 		.mode = BINI_STREAM,
···
 	kf_logdbg("loaded actors into binary stream: len=%lu", len);
 
 	const size_t nactors = bini_rlu(&bs);
+	kf_logdbg("expecting to load %lu actors", nactors);
 
 	for (size_t i = 0 ; i < nactors ; i++)
 	{
-		char key[4096] = {0};
-		bini_rstr(&bs, key);
-		int id = kf_actor_getregistryid(key);
+		kf_logdbg("loading actor #%lu", i);
+		char key[4096];
+		size_t n = bini_rstr(&bs, key);
+		key[n] = '\0';
+		char *keycpy = kf_strdup(key);
+		kf_logdbg("  key: %s", keycpy);
+		int id = kf_actor_getregistryid(keycpy);
+		kf_logdbg("  id: %d", id);
 		if (id == -1)
 			continue;
-		struct kf_actor *actor = kf_actor_new(key);
+		struct kf_actor *actor = kf_actor_new(keycpy);
 		kf_actorregistry.deserialize[id](actor, &bs);
 	}
 

src/graphics.c

···
 
 	struct kf_state *state = NULL;
 	int is_new_state = kf_state_load(&state);
+	(void)is_new_state;
 	kf_window.state = state;
 
 	struct kf_world *world = NULL;
···
 	kf_actorregistry.tick[idplayer2] = kf_player_tick;
 	kf_actorregistry.draw[idplayer2] = kf_player_draw;
 
-	if (is_new_state)
+	if (!kf_exists("data/actors.bin"))
 	{
-		struct kf_actor *player = kf_actors; /* player should always be the first actor. */
+		struct kf_actor *player = kf_actor_new("player");
+		player->controlled = true;
+		player->pos.x = world->width * KF_TILE_SIZE_PX / 2.0f;
+		player->pos.y = world->width * KF_TILE_SIZE_PX / 2.0f;
 
-		state->player.pos.x = world->width * KF_TILE_SIZE_PX / 2.0f;
-		state->player.pos.y = world->width * KF_TILE_SIZE_PX / 2.0f;
+		struct kf_actor *player2 = kf_actor_new("player2");
+		player2->pos.x = world->width * KF_TILE_SIZE_PX / 2.0f;
+		player2->pos.y = (world->width * KF_TILE_SIZE_PX / 2.0f) - 32;
 
 		kf_timeit("save actors", kf_saveactors());
 	}
···
 		kf_timeit("load actors", kf_loadactors());
 	}
 
-	struct kf_actor *player = kf_actors; /* player should always be the first actor. */
-	kf_window.player = player;
-
-	struct kf_actor *player2 = kf_actor_new("player2");
-	player2->size.x = 10;
-	player2->size.y = 10;
-	player2->collide = false;
-	player2->sizeoffset.y = 6;
-	player2->pos.x = player->pos.x;
-	player2->pos.y = player->pos.y - 24;
+	kf_window.player = kf_actors; /* player should always be the first actor. */
 
-	kf_window.cam.target.x = player->pos.x + (player->size.x / 2);
-	kf_window.cam.target.y = player->pos.y + (player->size.y / 2);
+	kf_window.cam.target.x = kf_window.player->pos.x + (kf_window.player->size.x / 2);
+	kf_window.cam.target.y = kf_window.player->pos.y + (kf_window.player->size.y / 2);
 	kf_window.cam.zoom = 2;
 
 	kf_setmodal(&kf_modal_play);
···
 
 	kf_saveactors();
 
-	kf_window.state->player.pos = kf_window.player->pos;
 	kf_state_save(kf_window.state);
 
 	free(kf_window.player);

src/player.c

···
 {
 	self->pos.x = bini_rf(bs);
 	self->pos.y = bini_rf(bs);
+	self->controlled = bini_rb(bs);
 }

src/string.c

···
+#include <keraforge.h>
+
+#include <string.h>
+
+
+char *kf_strdup(char *str)
+{
+	size_t n = strlen(str);
+	char *s = malloc(n + 1);
+	strcpy(s, str);
+	s[n] = '\0';
+	return s;
+}