Use bini for map (de)serialization

compile_flags.txt

···
 
 -DKF_SANITY_CHECKS
 -DKF_GNU
+-Dbini_impl
+-Dbini_dbg

include/keraforge/bini.h

···
 bini.h: endian-independent binary IO.
 License: BSD 3-Clause. See EOF for license text.
 
-Version: 1.0
+Version: 1.1
 
 Changelog:
   1.0 (Dec 28, 2025): Initial version.
+  1.1 (Dec 30, 2025): Use an offset instead of shifting the
+    byte buffer so carelessly. _bini_grow will shift the
+    buffer on-demand instead so as to conserve CPU time.
 */
 
 /* Used to add functions for version-specific types. */
···
 {
 	/* Read mode for the stream. Should be either BINI_STACK or BINI_STREAM. */
 	int mode;
+	/* Offset from the start of the buffer in bytes. Only used for BINI_STREAM. */
+	size_t off;
 	size_t cap;
 	size_t len;
 	uint8_t *buffer;
···
    buffer, and frees the provided variable as well. */
 void bini_close(struct bini_stream *bs);
 
+/* Shift a binary stream, resetting the offset and shifting the array. */
+void bini_shift(struct bini_stream *);
 /* Flush a binary stream, clearing its buffer. */
 int bini_flush(struct bini_stream *);
 /* Dump the binary stream's buffer to fp. */
···
 	bs->buffer = calloc(BINI_BUFSIZ, 1);
 	if (!bs->buffer)
 		return BINI_ERR;
+	bs->off = 0;
 	bs->len = 0;
 	bs->cap = BINI_BUFSIZ;
 	bs->mode = BINI_STREAM;
···
 	free(bs);
 }
 
+static
+#if bini_c >= 1999
+inline
+#endif
+void _bini_shiftleft(struct bini_stream *bs, size_t n)
+{
+	size_t i;
+	_bini_dbg("shift %d: (len=%lu)\n", n, bs->len);
+	for (i = 0 ; i < bs->len ; i++)
+	{
+		if (i+n >= bs->len)
+		{
+			_bini_dbg("      %d: [%d] (out of bounds) to [%d]\n", n, i+n, i);
+			bs->buffer[i] = 0;
+			continue;
+		}
+		_bini_dbg("      %d: [%d] (%02x '%c') to [%d]\n",
+			n,
+			i+n,
+			bs->buffer[i+n],
+			bs->buffer[i+n],
+			i);
+		bs->buffer[i] = bs->buffer[i+n];
+	}
+}
+
+void bini_shift(struct bini_stream *bs)
+{
+	_bini_shiftleft(bs, bs->off);
+	bs->off = 0;
+}
+
 int bini_flush(struct bini_stream *bs)
 {
 	size_t i;
···
 int _bini_grow(struct bini_stream *bs, size_t n)
 {
 	uint8_t *newbuf;
+
+	if (bs->off + bs->len + n < bs->cap)
+		return BINI_OK;
+
+	/* Shifting the array could give enough space to
+	   fit `n`, avoiding the need to realloc. */
+	bini_shift(bs);
+
 	if (bs->len + n < bs->cap)
 		return BINI_OK;
+
 	while (bs->len + n >= bs->cap)
 	{
 		newbuf = realloc(bs->buffer, bs->cap * 2);
···
 		bs->buffer = newbuf;
 		bs->cap *= 2;
 	}
+
 	return BINI_OK;
 }
 
···
 	return fwrite(bs->buffer, size, n, fp);
 }
 
-static
-#if bini_c >= 1999
-inline
-#endif
-void _bini_shiftleft(struct bini_stream *bs, size_t n)
-{
-	size_t i;
-	_bini_dbg("shift %d: (len=%lu)\n", n, bs->len);
-	for (i = 0 ; i < bs->len ; i++)
-	{
-		if (i+n >= bs->len)
-		{
-			_bini_dbg("      %d: [%d] (out of bounds) to [%d]\n", n, i+n, i);
-			bs->buffer[i] = 0;
-			continue;
-		}
-		_bini_dbg("      %d: [%d] (%02x '%c') to [%d]\n",
-			n,
-			i+n,
-			bs->buffer[i+n],
-			bs->buffer[i+n],
-			i);
-		bs->buffer[i] = bs->buffer[i+n];
-	}
-}
-
 #define _bini_rwx(_type, _name) \
 	void bini_w##_name(struct bini_stream *bs, _type v) \
 	{ \
···
 				l ? sizeof(v)-i-1 : i, \
 				bytes[l ? sizeof(v)-i-1 : i], \
 				bytes[l ? sizeof(v)-i-1 : i], \
-				bs->len+i); \
-			bs->buffer[bs->len+i] = bytes[l ? sizeof(v)-i-1 : i]; \
+				bs->off+bs->len+i); \
+			bs->buffer[bs->off+bs->len+i] = bytes[l ? sizeof(v)-i-1 : i]; \
 		} \
 		bs->len += i; \
 		_bini_dbg("-> %s: %d (%lu bytes)\n", __FUNCTION__, *(int *)bytes, sizeof(v)); \
···
 		int m = bs->mode == BINI_STREAM; \
 		for (i = 0 ; i < sizeof(v) ; i++) \
 		{ \
+			const size_t p = bs->off + (m ? i : (bs->len-sizeof(v)+i)); \
 			_bini_dbg("%s: byte index [%lu] from buffer index %lu (= %02x '%c')\n", \
 				__FUNCTION__, \
 				l ? sizeof(v)-i-1 : i, \
-				m ? i : (bs->len-sizeof(v)+i), \
-				bs->buffer[m ? i : (bs->len-sizeof(v)+i)], \
-				bs->buffer[m ? i : (bs->len-sizeof(v)+i)]); \
-			bytes[l ? sizeof(v)-i-1 : i] = bs->buffer[m ? i : (bs->len-sizeof(v)+i)]; \
+				p, \
+				bs->buffer[p], \
+				bs->buffer[p]); \
+			bytes[l ? sizeof(v)-i-1 : i] = bs->buffer[p]; \
 		} \
 		if (m) \
-			_bini_shiftleft(bs, i); \
+		{ \
+			bs->off += i; \
+			/* _bini_shiftleft(bs, i); */ \
+		} \
 		bs->len -= i; \
 		return v; \
 	}

include/keraforge/world.h

···
 
 
 /* Represents a singular tile in the world. */
+// struct kf_tile
+// {
+// 	kf_tileid_t subid   : KF_TILE_IDWIDTH;
+// 	kf_tileid_t id      : KF_TILE_IDWIDTH;
+// 	kf_tiledatum_t data : KF_TILE_DATAWIDTH;
+// } __attribute__((packed));
 struct kf_tile
 {
-	kf_tileid_t subid   : KF_TILE_IDWIDTH;
-	kf_tileid_t id      : KF_TILE_IDWIDTH;
-	kf_tiledatum_t data : KF_TILE_DATAWIDTH;
-} __attribute__((packed));
+	kf_tileid_t subid   ;//: KF_TILE_IDWIDTH;
+	kf_tileid_t id      ;//: KF_TILE_IDWIDTH;
+	kf_tiledatum_t data ;//: KF_TILE_DATAWIDTH;
+};// __attribute__((packed));
 
 /* Represents a world (or a subworld, often called "rooms"). */
 struct kf_world

scripts/run-valgrind.sh

···
+#!/usr/bin/env sh
+set -e
+
+if [ -e "./build/keraforge" ]
+then
+	valgrind --track-origins=yes --leak-check=full --show-leak-kinds=all -s ./build/keraforge
+else
+	echo ": error: no build available"
+	exit 1
+fi

src/editor.c

···
 	kf_logdbg("exiting editor, world is %s", d ? "dirty" : "not dirty");
 
 	if (d)
-		kf_world_save(kf_window.room, true);
+		kf_world_save(kf_window.room, false);
 
 	free(kf_window.modal->data);
 	kf_window.modal->data = NULL;

src/graphics.c

···
 	kf_window.state = state;
 
 	struct kf_world *world = NULL;
-	kf_world_load(&world, true);
+	kf_world_load(&world, false);
 	kf_window.room = world;
 
 	kf_actorregistry.id[0] = "player";

src/world.c

···
 #include "keraforge/bini.h"
-#include "keraforge/fs.h"
 #include <keraforge.h>
 #include <raylib.h>
 #include <stdio.h>
···
 	char *outfile = compress ? _KF_MAPFILE_TMP : _KF_MAPFILE;
 	struct bini_stream *bs = bini_new();
 	_kf_world_save_bs(world, bs);
-	if (kf_writebin(outfile, bs->buffer, bs->len))
+	if (!kf_writebin(outfile, bs->buffer, bs->len))
 		KF_THROW("failed to open %s", outfile);
 	bini_close(bs);
 
···
 }
 
 static
-void _kf_world_load_bs(struct kf_world *world, struct bini_stream *bs)
+void _kf_world_load_bs(struct kf_world **pworld, struct bini_stream *bs)
 {
-	world->revision = bini_riu(bs);
-	world->width = bini_riu(bs);
-	world->height = bini_riu(bs);
+	u32 r = bini_riu(bs);
+	u32 w = bini_riu(bs);
+	u32 h = bini_riu(bs);
+	struct kf_world *world = malloc(sizeof(*world) + sizeof(struct kf_tile)*w*h);
+	world->revision = r;
+	world->width = w;
+	world->height = h;
 	struct kf_tile *t = &world->map[0];
 	for (size_t i = 0 ; i < world->width*world->height ; i++)
 	{
···
 		t->data = bini_rcu(bs);
 		t++;
 	}
+	*pworld = world;
 }
 
 int kf_world_load(struct kf_world **pworld, bool compressed)
···
 	kf_logdbg("loading world: %s", infile);
 
 	size_t len = 0;
-	struct bini_stream *bs = bini_new();
-	free(bs->buffer);
-	bs->buffer = kf_readbin(infile, &len);
-	if (!bs->buffer)
+	struct bini_stream bs = {
+		.mode = BINI_STREAM,
+		.buffer = kf_readbin(infile, &len),
+	};
+	if (!bs.buffer)
 		KF_THROW("failed to read/open %s", infile);
-	bs->len = bs->cap = len;
-	_kf_world_load_bs(*pworld, bs);
-	bini_close(bs);
+	bs.cap = len;
+	bs.len = len;
+	kf_logdbg("loaded world into binary stream: len=%lu", len);
+	_kf_world_load_bs(pworld, &bs);
+	free(bs.buffer);
 	kf_logdbg("loaded world (%p): r=%d, wh=%dx%d, len=%lu", *pworld, (*pworld)->revision, (*pworld)->width, (*pworld)->height, len);
 
 	if (compressed)

tools/newgame.c

···
 
 	size_t len = kf_world_getsize(world);
 	kf_loginfo("saving world (%lu bytes uncompressed)", len);
-	if (!kf_writebin(worldpath, (u8 *)world, len))
-		KF_THROW("failed to save %s", worldpath);
+	kf_world_save(world, compress);
+	// if (!kf_writebin(worldpath, (u8 *)world, len))
+	// 	KF_THROW("failed to save %s", worldpath);
 
 	if (compress)
 	{