Implement basic tile rendering and a sanity checker

compile_flags.txt

···
 -Wall
 -Wextra
 -Werror
+
 -std=c99
 -Iinclude/
 -xc-header
+
+-DKF_SANITY_CHECKS
+-DKF_GNU

include/keraforge.h

···
 
 #include <keraforge/_header.h>
 #include <keraforge/actor.h>
+#include <keraforge/error.h>
 #include <keraforge/fs.h>
 #include <keraforge/graphics.h>
 #include <keraforge/input.h>

include/keraforge/_header.h

···
 #include <stdbool.h>
 
 
+#ifndef __FUNCTION_NAME__
+# ifdef WIN32
+#  define __FUNCTION_NAME__ __FUNCTION__
+# else
+#  define __FUNCTION_NAME__ __func__
+# endif
+#endif
+
+
+#ifdef KF_SANITY_CHECKS
+# include <stdio.h> /* fprintf, stderr */
+# include <stdlib.h> /* exit */
+# define KF_SANITY_CHECK(EXPR, ...) \
+	do \
+	{ \
+		if (!(EXPR)) \
+		{ \
+			fprintf(stderr, "\x1b[1;31msanity check failed: \x1b[0;34m%s:%d\x1b[0m in \x1b[34m%s: \x1b[0m", __FILE__, __LINE__, __FUNCTION_NAME__); \
+			fprintf(stderr, __VA_ARGS__); \
+			fprintf(stderr, "\n"); \
+			kf_printbacktrace(stderr); \
+			exit(1); \
+		} \
+	} \
+	while (0)
+# define KF_UNREACHABLE(...) \
+	do \
+	{ \
+		fprintf(stderr, "\x1b[1;31munreachable: \x1b[0;34m%s:%d\x1b[0m in \x1b[34m%s: \x1b[0m", __FILE__, __LINE__, __FUNCTION_NAME__); \
+		fprintf(stderr, __VA_ARGS__); \
+		fprintf(stderr, "\n"); \
+		kf_printbacktrace(stderr); \
+		exit(1); \
+	} \
+	while (0)
+#else
+# define KF_SANITY_CHECK(EXPR, ...) do { ; } while (0)
+# define KF_UNREACHABLE(...) do { ; } while (0)
+#endif
+
+
 typedef int8_t i8;
 typedef int16_t i16;
 typedef int32_t i32;

include/keraforge/error.h

···
+#ifndef __kf_error__
+#define __kf_error__
+
+
+#include <keraforge/_header.h>
+
+
+void kf_printbacktrace(FILE *file);
+
+
+#endif

include/keraforge/sprites.h

···
 
 /* Load a sprite sheet with the given sprite width/height. */
 struct kf_spritesheet kf_loadspritesheet(char *filename, int spritewidth, int spriteheight);
+/* Draw a single sprite from the sheet with a provided width and height. */
+void kf_drawsprite_wh(struct kf_spritesheet *sheet, f32 x, f32 y, f32 w, f32 h, int spritex, int spritey);
 /* Draw a single sprite from the sheet at the given coordinates. */
 void kf_drawsprite(struct kf_spritesheet *sheet, f32 x, f32 y, int spritex, int spritey);
 

include/keraforge/world.h

···
 
 #include <keraforge/_header.h>
 #include <keraforge/math.h>
+#include <keraforge/sprites.h>
 #include <raylib.h>
 
+
+#define KF_TILE_SIZE_PX 16
 
 #define KF_TILEID_MAX UINT16_MAX
 typedef u16 kf_tileid_t;
-#define KF_TILE_SIZE_PX 16
+/* Used to store connectivity variant. */
+typedef u16 kf_tiledatum_t;
 
 
 struct kf_actor; /* Forward declaration */
 
 
+#define KF_TILEMASK_NORTH (0x0001)
+#define KF_TILEMASK_WEST  (0x0010)
+#define KF_TILEMASK_EAST  (0x0100)
+#define KF_TILEMASK_SOUTH (0x1000)
+
+
+/* Represents a singular tile in the world. */
+struct kf_tile
+{
+	kf_tileid_t id;
+	kf_tiledatum_t data;
+};
+
 /* Represents a world (or a subworld, often called "rooms"). */
 struct kf_world
 {
···
 	/* Height of the map. */
 	u32 height;
 	/* Array of tiles in the map. Use kf_gettile to get a tile using an X/Y position. */
-	kf_tileid_t map[];
+	struct kf_tile map[];
 };
 
 /* Struct-of-arrays for tiles. See: kf_tiles */
···
 /* Struct-of-arrays for tiles. */
 extern struct _kf_tiles kf_tiles;
 
+/* Options for creating tiles using addtile and addtiles. */
+struct kf_tile_opts
+{
+	char *key;
+	Color mapcol;
+	struct kf_spritesheet *sheet;
+	struct kf_vec2(u32) sprite;
+	bool collide;
+};
+
+kf_tileid_t kf_addtile(struct kf_tile_opts opts);
+#define KF_ADDTILE(...) (kf_addtile((struct kf_tile_opts){ __VA_ARGS__ }))
+
 /* Create a world using the given width and height.
    Fills the map with the given `fill` tile. */
 struct kf_world *kf_world_new(u32 width, u32 height, kf_tileid_t fill);
···
 /* Get the size of the world in bytes. */
 size_t kf_world_getsize(struct kf_world *world);
 
+/* Get the sprite offset for a given tile datum. */
+struct kf_vec2(u32) kf_getspritefortilebitmask(kf_tiledatum_t t);
+
+/* Update a tile and optionally its neighbours. */
+void kf_world_updatetile(struct kf_world *world, u32 x, u32 y, bool update_neighbours);
+
 /* Get a pointer to the tile ID at a given position. */
-kf_tileid_t *kf_world_gettile(struct kf_world *world, u32 x, u32 y);
+struct kf_tile *kf_world_gettile(struct kf_world *world, u32 x, u32 y);
 
 /* Draw visible collision rectangles. */
 void kf_world_drawcolliders(struct kf_world *world, struct kf_actor *player, Camera2D camera);

scripts/_config.sh

···
 	export CC="ccache $CC"
 fi
 
-export CFLAGS="-Wall -Wextra -Werror -std=c99 -Iinclude/ -c"
-export LFLAGS="-lraylib -lm -lGL -lpthread -ldl -lrt -lX11"
+export KF_DEBUG_CFLAGS="-g -DKF_SANITY_CHECKS"
+export KF_DEBUG_LFLAGS="-g -rdynamic"
+
+export CFLAGS="-Wall -Wextra -Werror -std=c99 -Iinclude/ -c -DKF_GNU $KF_DEBUG_CFLAGS"
+export LFLAGS="-lraylib -lm -lGL -lpthread -ldl -lrt -lX11 $KF_DEBUG_LFLAGS"

scripts/run.sh

···
 
 if [ -e "./build/keraforge" ]
 then
-	./build/keraforge
+	gdb -q -ex "set debuginfod enabled off" -ex "file ./build/keraforge" -ex "run"
 else
 	echo ": error: no build available"
 	exit 1

src/actor.c

···
 		KF_TILE_SIZE_PX - 1,
 	}; /* tile rect */
 	u32 x;
-	kf_tileid_t *tile = kf_world_gettile(world, sx, sy);
+	struct kf_tile *tile = kf_world_gettile(world, sx, sy);
 
 	for (u32 y = sy ; y <= ey ; y++)
 	{
 		for (x = sx ; x <= ex ; x++)
 		{
-			if (kf_tiles.collide[*tile] && CheckCollisionRecs(r, tr))
+			if (kf_tiles.collide[tile->id] && CheckCollisionRecs(r, tr))
 				return 0;
 			tile++; /* shift tile pointer to the right */
 			tr.x += KF_TILE_SIZE_PX;

src/error.c

···
+#include <keraforge.h>
+
+#if KF_GNU
+#include <execinfo.h>
+#endif
+
+
+void kf_printbacktrace(FILE *file)
+{
+#if KF_GNU
+	static const int maxtracelen = 128;
+	void *trace[maxtracelen];
+
+	int size = backtrace(trace, maxtracelen);
+	char **strings = backtrace_symbols(trace, size);
+	if (strings)
+	{
+		fprintf(file, "backtrace: (%d frames)\n", size);
+		for (int i = 0 ; i < size ; i++)
+			fprintf(file, " %d: %s\n", size-i, strings[i]);
+	}
+	else
+	{
+		fprintf(file, "failed to obtain backtrace\n");
+	}
+
+	free(strings);
+#else
+	fprintf(file, "kf_printbacktrace requires GNU extensions (execinfo.h)\n");
+#endif
+}

src/main.c

···
-#include "keraforge/input.h"
 #include <keraforge.h>
 #include <raylib.h>
 #include <raymath.h>
···
 	/* gamepad axis movement */
 	f32 gpx = kf_getgamepadaxis(inputbind_move_left);
 	f32 gpy = kf_getgamepadaxis(inputbind_move_up);
-	// f32 gpx = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_X);
-	// f32 gpy = GetGamepadAxisMovement(0, GAMEPAD_AXIS_LEFT_Y);
 	if (gpx > kf_deadzone || gpx < -kf_deadzone || gpy > kf_deadzone || gpy < -kf_deadzone)
 	{
 		v.y = gpy;
···
 	(void)argc;
 	(void)argv;
 
-	SetTraceLogLevel(LOG_WARNING);
+	// SetTraceLogLevel(LOG_WARNING);
 	InitWindow(800, 600, "Keraforge");
 	SetTargetFPS(60);
 	SetExitKey(KEY_NULL);
 
 	loadbinds();
 
-	kf_tiles.key[0] = "grass";
-	kf_tiles.mapcol[0] = GREEN;
-	kf_tiles.key[1] = "dirt";
-	kf_tiles.mapcol[1] = BROWN;
-	kf_tiles.key[2] = "stone";
-	kf_tiles.mapcol[2] = GRAY;
-	kf_tiles.collide[2] = true;
-	kf_tiles.count = 3;
+	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},
+		.collide = true,
+	);
+	KF_ADDTILE(
+		.key = "debug",
+		.mapcol = BLUE,
+		.sheet = &terrain,
+		.sprite = {4, 4},
+	);
+	printf("loaded %d tiles\n", kf_tiles.count);
 
 	struct kf_uiconfig *uiconfig = kf_ui_getconfig();
 	uiconfig->select = inputbind_select;
···
 	if (!kf_exists("data/map.bin"))
 	{
 		printf("-> creating world\n");
-		world = kf_world_new(128, 128, 0);
-		for (size_t i = 0 ; i < world->width*world->height ; i += (size_t)((float)(rand())/RAND_MAX*10))
-			world->map[i] = (rand()/(float)RAND_MAX*3);
+		world = kf_world_new(128, 128, 1);
 		printf("-> saving world\n");
 		size_t len = kf_world_getsize(world);
 		printf("-> writing of %lu bytes\n", len);
···
 			cam.zoom -= 0.25f;
 
 		BeginDrawing();
-		ClearBackground(WHITE);
+		ClearBackground(BLACK);
 
 		BeginMode2D(cam);
 		kf_world_draw(world, cam);
 		// kf_world_drawcolliders(world, player, cam);
 		if (select.x < world->width && select.y < world->height)
 		{
+			struct kf_tile *t = kf_world_gettile(world, select.x, select.y);
 			if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
 			{
-				kf_tileid_t *t = kf_world_gettile(world, select.x, select.y);
-				*t = (kf_tileid_t)selected_tile;
+				t->id = (kf_tileid_t)selected_tile;
+				kf_world_updatetile(world, select.x, select.y, true);
 			}
 			DrawRectangleLines(select.x * KF_TILE_SIZE_PX, select.y * KF_TILE_SIZE_PX, KF_TILE_SIZE_PX, KF_TILE_SIZE_PX, WHITE);
+			struct kf_vec2(u32) s = kf_getspritefortilebitmask(t->data);
+			DrawText(TextFormat("%d [0x%04x] (%d,%d) {%d,%d}", t->id, t->data, select.x, select.y, s.x, s.y), select.x * KF_TILE_SIZE_PX, select.y * KF_TILE_SIZE_PX - 10, 10, BLACK);
 		}
 		player->draw(world, player);
 		EndMode2D();
···
 			case menu_none:
 				break;
 			case menu_palette:
-				if (kf_ui_choice("Select tile", &kf_tiles.key[0], kf_tiles.count, &selected_tile))
+				if (kf_ui_choice("Select tile", &kf_tiles.key[0], kf_tiles.count + 1, &selected_tile))
 					setmenu(menu_none);
 				break;
 			case menu_escape:

src/sprites.c

···
 }
 
 inline
-void kf_drawsprite(struct kf_spritesheet *sheet, f32 x, f32 y, int spritex, int spritey)
+void kf_drawsprite_wh(struct kf_spritesheet *sheet, f32 x, f32 y, f32 w, f32 h, int spritex, int spritey)
 {
+	KF_SANITY_CHECK(sheet != NULL, "spritesheet is null");
+
 	DrawTexturePro(
 		sheet->texture,
 		(Rectangle){
···
 			spritey * sheet->spriteheight,
 			sheet->spritewidth,
 			sheet->spriteheight },
-		(Rectangle){
-			x,
-			y,
-			sheet->spritewidth,
-			sheet->spriteheight },
-		(Vector2){0, 0},
+		(Rectangle){ x, y, w, h },
+		(Vector2){ 0, 0 },
 		0,
 		WHITE
 	);
 }
+
+inline
+void kf_drawsprite(struct kf_spritesheet *sheet, f32 x, f32 y, int spritex, int spritey)
+{
+	kf_drawsprite_wh(sheet, x, y, sheet->spritewidth, sheet->spriteheight, spritex, spritey);
+}

src/world.c

···
+#include "keraforge/world.h"
 #include <keraforge.h>
 #include <raylib.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
···
 struct _kf_tiles kf_tiles = {0};
 
 
+static inline
+void _kf_updatetilebitmask(struct kf_world *world, u32 x, u32 y);
+
+
+kf_tileid_t kf_addtile(struct kf_tile_opts opts)
+{
+	KF_SANITY_CHECK(opts.key != NULL, "tile added without key");
+	KF_SANITY_CHECK(opts.sheet != NULL, "tile added without sheet");
+
+	kf_tileid_t id = ++kf_tiles.count;
+
+	kf_tiles.key[id] = opts.key;
+	kf_tiles.mapcol[id] = opts.mapcol;
+	kf_tiles.sheet[id] = opts.sheet;
+	kf_tiles.sprite[id] = opts.sprite;
+	kf_tiles.collide[id] = opts.collide;
+
+	return id;
+}
+
 struct kf_world *kf_world_new(u32 width, u32 height, kf_tileid_t fill)
 {
-	const size_t len = sizeof(kf_tileid_t) * width * height;
-	struct kf_world *world = malloc(sizeof(struct kf_world) + len);
+	const size_t len = sizeof(struct kf_world) + sizeof(struct kf_tile)*width*height;
+	struct kf_world *world = malloc(len);
+	printf("creating world: %lu bytes: %p\n", len, world);
 	world->revision = 0;
 	world->width = width;
 	world->height = height;
-	memset(world->map, fill, len);
+	memset(world->map, 0, sizeof(struct kf_tile)*width*height);
+	for (size_t i = 0 ; i < width*height ; i++)
+		world->map[i].id = fill;
+
+	u32 x;
+	for (u32 y = 0 ; y < height ; y++)
+	{
+		for (x = 0 ; x < width ; x++)
+		{
+			_kf_updatetilebitmask(world, x, y);
+		}
+	}
+
 	return world;
 }
 
 size_t kf_world_getsize(struct kf_world *world)
 {
-	return sizeof(struct kf_world) + sizeof(kf_tileid_t)*world->width*world->height;
+	return sizeof(struct kf_world) + sizeof(struct kf_tile)*world->width*world->height;
+}
+
+static inline
+void _kf_updatetilebitmask(struct kf_world *world, u32 x, u32 y)
+{
+	struct kf_tile *t = kf_world_gettile(world, x, y);
+	kf_tileid_t
+		n = y-1 >= world->height ? 0 : kf_world_gettile(world, x, y-1)->id,
+		w = x-1 >= world->width  ? 0 : kf_world_gettile(world, x-1, y)->id,
+		e = x+1 >= world->width  ? 0 : kf_world_gettile(world, x+1, y)->id,
+		s = y+1 >= world->height ? 0 : kf_world_gettile(world, x, y+1)->id;
+	t->data = 0x0000;
+	if (t->id == n) t->data |= KF_TILEMASK_NORTH;
+	if (t->id == w) t->data |= KF_TILEMASK_WEST;
+	if (t->id == e) t->data |= KF_TILEMASK_EAST;
+	if (t->id == s) t->data |= KF_TILEMASK_SOUTH;
 }
 
-kf_tileid_t *kf_world_gettile(struct kf_world *world, u32 x, u32 y)
+void kf_world_updatetile(struct kf_world *world, u32 x, u32 y, bool update_neighbours)
+{
+	_kf_updatetilebitmask(world, x, y);
+	if (update_neighbours)
+	{
+		if (y-1 < world->height) kf_world_updatetile(world, x, y-1, false);
+		if (x-1 < world->width)  kf_world_updatetile(world, x-1, y, false);
+		if (x+1 < world->width)  kf_world_updatetile(world, x+1, y, false);
+		if (y+1 < world->height) kf_world_updatetile(world, x, y+1, false);
+	}
+}
+
+inline
+struct kf_vec2(u32) kf_getspritefortilebitmask(kf_tiledatum_t t)
+{
+	switch (t)
+	{
+	case 0x0000: return (struct kf_vec2(u32)){0, 3}; /* 0x0000: */
+	case 0x0001: return (struct kf_vec2(u32)){0, 2}; /* 0x0001: N */
+	case 0x0010: return (struct kf_vec2(u32)){3, 3}; /* 0x0010: W */
+	case 0x0011: return (struct kf_vec2(u32)){3, 2}; /* 0x0011: NW */
+	case 0x0100: return (struct kf_vec2(u32)){1, 3}; /* 0x0100: E */
+	case 0x0101: return (struct kf_vec2(u32)){1, 2}; /* 0x0101: EN */
+	case 0x0110: return (struct kf_vec2(u32)){2, 3}; /* 0x0110: EW */
+	case 0x0111: return (struct kf_vec2(u32)){2, 2}; /* 0x0111: EWN */
+	case 0x1000: return (struct kf_vec2(u32)){0, 0}; /* 0x1000: S */
+	case 0x1001: return (struct kf_vec2(u32)){0, 1}; /* 0x1001: SN */
+	case 0x1010: return (struct kf_vec2(u32)){3, 0}; /* 0x1010: SW */
+	case 0x1011: return (struct kf_vec2(u32)){3, 1}; /* 0x1011: SWN */
+	case 0x1100: return (struct kf_vec2(u32)){1, 0}; /* 0x1100: SE */
+	case 0x1101: return (struct kf_vec2(u32)){1, 1}; /* 0x1101: SEN */
+	case 0x1110: return (struct kf_vec2(u32)){2, 0}; /* 0x1110: SEW */
+	case 0x1111: return (struct kf_vec2(u32)){2, 1}; /* 0x1111: NESW */
+	}
+	KF_UNREACHABLE("invalid bitmask: 0x%x", t);
+	return (struct kf_vec2(u32)){-1, -1};
+}
+
+struct kf_tile *kf_world_gettile(struct kf_world *world, u32 x, u32 y)
 {
 	return &world->map[y*world->width + x];
 }
···
 	const u32 ex = fmin(world->width, ceilf(end.x / KF_TILE_SIZE_PX));
 	const u32 ey = fmin(world->height, ceilf(end.y / KF_TILE_SIZE_PX));
 	const size_t down = world->width - ex + sx - 1; /* number of indexes to add to reach the next tile down */
-	kf_tileid_t *tile = kf_world_gettile(world, sx, sy);
+	struct kf_tile *tile = kf_world_gettile(world, sx, sy);
 
 	/* check if any tiles will collide with the actor's rect */
 	const f32 trx = sx * KF_TILE_SIZE_PX;
···
 	{
 		for (x = sx ; x <= ex ; x++)
 		{
-			if (kf_tiles.collide[*tile])
+			if (kf_tiles.collide[tile->id])
 				DrawRectangleLinesEx(tr, 1, CheckCollisionRecs(r, tr) ? RED : BLACK);
 
 			tile++; /* shift tile pointer to the right */
···
 	const u32 ex = fmin(world->width, ceilf(end.x / KF_TILE_SIZE_PX));
 	const u32 ey = fmin(world->height, ceilf(end.y / KF_TILE_SIZE_PX));
 	const size_t down = world->width - ex + sx; /* number of indexes to add to reach the next tile down */
-	kf_tileid_t *tile = kf_world_gettile(world, sx, sy);
+	struct kf_tile *tile = kf_world_gettile(world, sx, sy);
 	u32 x;
 	for (u32 y = sy ; y < ey ; y++)
 	{
 		for (x = sx ; x < ex ; x++)
 		{
-			DrawRectangle(
-				(int)x * KF_TILE_SIZE_PX,
-				(int)y * KF_TILE_SIZE_PX,
-				KF_TILE_SIZE_PX,
-				KF_TILE_SIZE_PX,
-				kf_tiles.mapcol[*tile]
-			);
+			KF_SANITY_CHECK(tile->id <= kf_tiles.count, "erroneous tile on map at %u,%u: %u (count=%u)", x, y, tile->id, kf_tiles.count);
+			if (tile->id)
+			{
+				struct kf_vec2(u32) s = kf_getspritefortilebitmask(tile->data);
+				kf_drawsprite_wh(
+					kf_tiles.sheet[tile->id],
+					x*KF_TILE_SIZE_PX,
+					y*KF_TILE_SIZE_PX,
+					KF_TILE_SIZE_PX,
+					KF_TILE_SIZE_PX,
+					kf_tiles.sprite[tile->id].x + s.x,
+					kf_tiles.sprite[tile->id].y + s.y
+				);
+			}
 			tile++; /* shift tile pointer to the right */
 		}
 		tile += down; /* shift tile pointer down */