Start on actor (de)serialization TODO: Add a binary IO library similar to Minecraft's ByteBuf API.

include/keraforge/actor.h

···
 #include <raylib.h>
 
 
+/* The maximum number of registered actors. */
+#define KF_MAX_ACTOR_TYPES 1024
+
+
+/* Stores serializers and deserializers for actors. Any actor you plan to save MUST be registered here!
+   TODO: This will probably be better as a hash table (especially for kf_actor_getregistryid). */
+struct kf_actorregistry
+{
+	int count;
+	char *id[KF_MAX_ACTOR_TYPES];
+	u8 *(*serialize[KF_MAX_ACTOR_TYPES])(struct kf_actor *self, size_t *plen);
+	void (*deserialize[KF_MAX_ACTOR_TYPES])(struct kf_actor *self, u8 *data, size_t len);
+};
+/* Global actor registry instance. */
+extern struct kf_actorregistry kf_actorregistry;
+
 /* Represents any kinematic body in the world (players, NPCs, etc). */
 struct kf_actor
 {
+	/* Unique string identifier for this actor. */
+	char *id;
 	/* Spritesheet for the actor. */
 	struct kf_spritesheet sprites;
 	/* The actor's position. */
···
 	void (*tick)(struct kf_actor *self);
 	/* Called every frame to render the actor. */
 	void (*draw)(struct kf_actor *self);
+	/* Doubly-linked list of actors. */
+	struct kf_actor *prev, *next;
 };
+/* Linked list of actors. */
+extern struct kf_actor *kf_actors, *kf_actors_last;
+extern u32 kf_actor_count;
 
 
 /* Create a new actor. */
-struct kf_actor *kf_actor_new(struct kf_spritesheet sprites, f32 width, f32 height, bool collides);
+struct kf_actor *kf_actor_new(char *id, struct kf_spritesheet sprites, f32 width, f32 height, bool collides);
 
 /* Load a spritesheet, filling in the details for loading character spritesheets. */
 struct kf_spritesheet kf_actor_loadspritesheet(char *filename);
···
 void kf_actor_move(struct kf_world *world, struct kf_actor *actor, f32 deltatime);
 /* Draw the actor. */
 void kf_actor_draw(struct kf_actor *actor);
+
+/* Get the registry ID of a given actor ID.
+   This will perform a lot of string comparisons, use sparingly! */
+int kf_actor_getregistryid(char *id);
+
+/* Save actor data. */
+int kf_saveactors(void);
 
 
 #endif

include/keraforge/player.h

···
 void kf_player_tick(struct kf_actor *self);
 void kf_player_draw(struct kf_actor *self);
 
+u8* kf_player_serialize(struct kf_actor *self, size_t *plen);
+void kf_player_deserialize(struct kf_actor *self, u8 *data, size_t len);
 
 #endif

src/actor.c

···
+#include "keraforge/fs.h"
 #include <keraforge.h>
 #include <stdlib.h>
 #include <raymath.h>
+#include <string.h>
+
 
+struct kf_actorregistry kf_actorregistry = {0};
+struct kf_actor *kf_actors = NULL, *kf_actors_last = NULL;
+u32 kf_actor_count = 0;
 
-struct kf_actor *kf_actor_new(struct kf_spritesheet sprites, f32 width, f32 height, bool collides)
+
+struct kf_actor *kf_actor_new(char *id, struct kf_spritesheet sprites, f32 width, f32 height, bool collides)
 {
 	struct kf_actor *actor = calloc(1, sizeof(struct kf_actor));
+	kf_actor_count++;
 
+	if (!kf_actors)
+	{
+		kf_actors = kf_actors_last = actor;
+	}
+	else
+	{
+		actor->prev = kf_actors_last;
+		kf_actors_last->next = actor;
+		kf_actors_last = actor;
+	}
+
+	actor->id = id;
 	actor->sprites = sprites;
 	actor->size.x = width;
 	actor->size.y = height;
···
 
 	kf_drawsprite(&actor->sprites, actor->pos.x, actor->pos.y, x, y);
 }
+
+int kf_actor_getregistryid(char *id)
+{
+	size_t l = strlen(id);
+	for (int i = 0 ; i < kf_actorregistry.count ; i++)
+	{
+		char *c = kf_actorregistry.id[i];
+		size_t cl = strlen(c);
+		if (strncmp(c, id, l>cl?l:cl) == 0)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+#define _KF_ACTORFILE_TMP "data/tmp/actors.bin"
+#define _KF_ACTORFILE_XZ "data/actors.bin.xz"
+#define _KF_ACTORFILE "data/actors.bin"
+
+int kf_saveactors(void)
+{
+	// char *outfile = compress ? _KF_ACTORFILE_TMP : _KF_ACTORFILE;
+	char *outfile = _KF_ACTORFILE;
+
+	FILE *fp = fopen(outfile, "wb");
+	if (!fp)
+		KF_THROW("failed to open %s", outfile);
+
+	size_t nactors = 0;
+	size_t total_bytes = 0;
+
+	for (struct kf_actor *actor = kf_actors ; actor != NULL ; actor = actor->next)
+	{
+		if (!actor->id)
+			continue;
+		int id = kf_actor_getregistryid(actor->id);
+		if (id == -1)
+			continue;
+		size_t n = strlen(actor->id);
+		if (fwrite(actor->id, 1, n, fp) != n)
+		{
+			KF_THROWSOFTER("failed to write actor ID: %s", actor->id);
+			fclose(fp);
+			return 0;
+		}
+		n = 0;
+		u8 *data = kf_actorregistry.serialize[id](actor, &n);
+		if (!data)
+		{
+			KF_THROWSOFTER("failed to serialize actor of type %s", actor->id);
+			fclose(fp);
+			return 0;
+		}
+		if (fwrite(data, 1, n, fp) != n)
+		{
+			KF_THROWSOFTER("failed to write serialized actor of type %s", actor->id);
+			fclose(fp);
+			return 0;
+		}
+		nactors++;
+		total_bytes += n;
+	}
+
+	kf_logdbg("serialized %d actors (%lu bytes)", nactors, total_bytes);
+	fclose(fp);
+
+	return 1;
+}

src/graphics.c

···
+#include "keraforge/actor.h"
 #include <keraforge.h>
 #include <raylib.h>
 
···
 	kf_world_load(&world, true);
 	kf_window.room = world;
 
-	struct kf_actor *player = kf_actor_new(kf_actor_loadspritesheet("data/res/img/char/template.png"), 10, 10, true);
+	kf_actorregistry.id[0] = "player";
+	kf_actorregistry.serialize[0] = kf_player_serialize;
+	kf_actorregistry.deserialize[0] = kf_player_deserialize;
+	kf_actorregistry.count++;
+
+	struct kf_actor *player = kf_actor_new("player", kf_actor_loadspritesheet("data/res/img/char/template.png"), 10, 10, true);
 	player->sizeoffset.y = 6;
 	player->tick = kf_player_tick;
 	player->draw = kf_player_draw;
···
 	player->pos.y = state->player.pos.y;
 	kf_window.player = player;
 
+	struct kf_actor *player2 = kf_actor_new("player", kf_actor_loadspritesheet("data/res/img/char/whom.png"), 10, 10, true);
+	player2->sizeoffset.y = 6;
+	player2->tick = kf_player_tick; /* when controlled is false, player_tick won't process keybinds */
+	player2->draw = kf_player_draw;
+	player2->pos.x = player->pos.x;
+	player2->pos.y = player->pos.y - 24;
+
 	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.zoom = 2;
···
 	kf_window.running = 1;
 	kf_window.cam.offset.x = GetScreenWidth() / 2.0f;
 	kf_window.cam.offset.y = GetScreenHeight() / 2.0f;
+
 	while (!WindowShouldClose() && kf_window.running)
 	{
 		if (IsWindowResized())
···
 	kf_setmenu(NULL);
 	kf_setmodal(NULL);
 
+	kf_saveactors();
+
 	kf_window.state->player.pos = kf_window.player->pos;
 	kf_state_save(kf_window.state);
 
···
 static
 void _kf_modal_play_update(void)
 {
-	kf_window.player->tick(kf_window.player);
+	// kf_window.player->tick(kf_window.player);
+	for (struct kf_actor *actor = kf_actors ; actor != NULL ; actor = actor->next)
+		actor->tick(actor);
 
 	Vector2 v = GetScreenToWorld2D(GetMousePosition(), kf_window.cam);
 	kf_window.select.x = v.x / KF_TILE_SIZE_PX;
···
 {
 	kf_world_draw(kf_window.room, kf_window.cam);
 	// kf_world_drawcolliders(world, player, cam);
-	kf_window.player->draw(kf_window.player);
+	// kf_window.player->draw(kf_window.player);
+	for (struct kf_actor *actor = kf_actors ; actor != NULL ; actor = actor->next)
+		actor->draw(actor);
 }
 
 static

src/player.c

···
 
 void kf_player_tick(struct kf_actor *self)
 {
-	if (!kf_window.menu)
+	if (!kf_window.menu && self->controlled)
 	{
 		_player_tick_move(self);
 
···
 {
 	kf_actor_draw(self);
 
-	kf_window.cam.target.x = self->pos.x + (self->size.x / 2);
-	kf_window.cam.target.y = self->pos.y + (self->size.y / 2);
+	if (self->controlled)
+	{
+		kf_window.cam.target.x = self->pos.x + (self->size.x / 2);
+		kf_window.cam.target.y = self->pos.y + (self->size.y / 2);
+	}
+}
+
+
+struct _kf_serialized_player
+{
+	struct kf_vec2(f32) pos;
+};
+
+u8* kf_player_serialize(struct kf_actor *self, size_t *plen)
+{
+	*plen = sizeof(struct _kf_serialized_player);
+	struct _kf_serialized_player *s = malloc(*plen);
+	s->pos = self->pos;
+	return (u8 *)s;
+}
+
+void kf_player_deserialize(struct kf_actor *self, u8 *data, size_t len)
+{
+	(void)len;
+	struct _kf_serialized_player *s = (struct _kf_serialized_player *)data;
+	self->pos = s->pos;
 }