linije

linije.c (61754B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2025-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 /*
  * Term definitions
  *
  * 	ball string	A set of adjacent (horizontally, vertically or
  * 			diagonally) balls with the same color
  *
  *	popping the string
  * 			Erasing all the balls in the string from the board
  */
 #include <SDL3/SDL.h>
 #include <SDL3_image/SDL_image.h>
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "hiscore.h"
 #include "local.h"
 #include "version.h"
 
 /* clang-format off */
 #define ANIM_SPEED 100 /* how long does it take for the animation to go
 		        * from start to finish (ms) */
 /* clang-format on */
 #define FPS	   60
 #define ANIM_STEPS (ANIM_SPEED * FPS / 1000)
 
 #define BOLD_START		'\1'
 #define BOLD_END		'\2'
 #define CENTER_LINE		'\3'
 #define DIM_START		'\4'
 #define DIM_END			'\2'
 #define CELL_SCALE_FACTOR	2.0f
 #define BUFSIZE			4096
 #define CELL_SIZE		20
 #define DEFAULT_WIDTH		1280
 #define DEFAULT_HEIGHT		720
 #define HOF_DIALOG_MAX_LINE_LEN 80
 // #define HOF_DIALOG_TEXT_ORIGIN_X 70
 #define HOF_DIALOG_TEXT_ORIGIN_X 0
 #define HOF_STANDOUT_ENTRIES	 3
 #define GAME_OVER_DIALOG_WIDTH	 270
 #define GAME_OVER_DIALOG_HEIGHT	 110
 #define GRID_WIDTH		 15
 #define GRID_HEIGHT		 15
 #define INPUT_WIDTH		 600
 #define INPUT_HEIGHT		 120
 #define LOCATION_STACK_MAX	 (GRID_WIDTH * GRID_HEIGHT)
 #define MIN_POP_LEN		 5
 /* clang-format off */
 #define POP_STRING_CELL_VALUE 100 /* Multiplied by # of balls in a string and
 				   * added to score when popping a string */
 /* clang-format on */
 #define PRINT_BUFSIZE	    4096
 #define PROGNAME	    "linije"
 #define QUIT_MSGBOX_WIDTH   450
 #define QUIT_MSGBOX_HEIGHT  150
 #define TER12_WIDTH	    6
 #define TER12_HEIGHT	    12
 #define TEXT_OPACITY_DIM    0.3f
 #define TEXT_OPACITY_NORMAL 0.6f
 #define TEXT_OPACITY_BOLD   1.0f
 #define TEXT_SCALE_FACTOR   2.0f
 #define WIN_TITLE	    "Linije"
 
 #define HELP_DIALOG_WIDTH  TER12_WIDTH * 75 * TEXT_SCALE_FACTOR
 #define HELP_DIALOG_HEIGHT TER12_HEIGHT * 20 * TEXT_SCALE_FACTOR
 #define HOF_DIALOG_WIDTH \
 	TER12_WIDTH*(HOF_DIALOG_MAX_LINE_LEN + 3) * TEXT_SCALE_FACTOR
 #define HOF_DIALOG_HEIGHT TER12_HEIGHT * 19 * TEXT_SCALE_FACTOR
 
 #define MIN(a, b)     (((a) < (b)) ? (a) : (b))
 #define MAX(a, b)     (((a) > (b)) ? (a) : (b))
 #define INDEX(x, y)   ((y) * GRID_WIDTH + (x))
 #define INDEXFI(x, y) (((int)floor(y)) * GRID_WIDTH + ((int)floor(x)))
 #define UNUSED(x)     ((void)(x))
 #define VALNAME(n)    [n] = #n
 
 /* clang-format off */
 enum {
 	CELL_EMPTY,
 	CELL_RED,
 	CELL_BLUE,
 	CELL_GREEN,
 	CELL_PURPLE,
 	CELL_ORANGE,
 	CELL_SELECTED
 };
 
 enum {
 	STATE_IDLE,
 	STATE_SELECTION,
 	STATE_MOVING,
 	STATE_GAME_OVER
 };
 
 const char* cell_names[] = {
 	VALNAME(CELL_EMPTY),
 	VALNAME(CELL_RED),
 	VALNAME(CELL_BLUE),
 	VALNAME(CELL_GREEN),
 	VALNAME(CELL_PURPLE),
 	VALNAME(CELL_ORANGE),
 	VALNAME(CELL_SELECTED),
 };
 
 const int check_five_deltas[][4] = {
 	{ -1, -1,  1, 1 },
 	{  1, -1, -1, 1 },
 	{  0, -1,  0, 1 },
 	{ -1,  0,  1, 0 },
 };
 
 const SDL_Point sprite_positions[] = {
 	[CELL_EMPTY]	= { .x = 0,		.y = 0			},
 	[CELL_RED]	= { .x = 1 * CELL_SIZE,	.y = 0			},
 	[CELL_BLUE]	= { .x = 2 * CELL_SIZE,	.y = 0			},
 	[CELL_GREEN]	= { .x = 3 * CELL_SIZE,	.y = 0			},
 	[CELL_PURPLE]	= { .x = 4 * CELL_SIZE,	.y = 0			},
 	[CELL_ORANGE]	= { .x = 5 * CELL_SIZE,	.y = 0			},
 	[CELL_SELECTED]	= { .x = 0,		.y = 1 * CELL_SIZE	},
 };
 
 const char* state_descriptions[] = {
 	"Idle",
 	"Selecting",
 	"Moving",
 	"Game over"
 };
 
 const char* game_over_text[] = {
 	"\3==== \1GAME OVER\2 ====",
 	"\3Press \1F2\2 to restart",
 	NULL
 };
 
 const char* help_text[] = {
 	"\3==== \1linije - Color lines clone\2 ====",
 	"\3\\\\ Version " VERSION " //",
 	"",
 	"\1F1\2        - Show this help screen",
 	"\1F2\2        - Restart the game",
 	"\1F3\2        - Show the hall of fame",
 	"\1Esc\2       - Hide this help screen",
 	"\1Alt+Enter\2 - Toggle fullscreen",
 	"\1Ctrl+Q\2    - Exit",
 	"",
 	"---",
 	"",
 	"\4This program is licensed under the terms of GNU GPL v3 or (at your\2",
 	"\4option) any later version. Copyright (C) 2025-2026  Strahinya Radich.\2",
 	"\4See the file LICENSE for exact copyright and license details.\2",
 	NULL
 };
 
 const char* name_text[] = {
 	"\3==== \1ENTER YOUR NAME\2 ====",
 	"",
 	NULL
 };
 
 const char* quit_msgbox_text[] = {
 	"\3==== \1CONFIRM\2 ====",
 	"",
 	"\3Do you really want to quit [\1y\2/\1n\2]?",
 	NULL
 };
 
 const char* restart_msgbox_text[] = {
 	"\3==== \1CONFIRM\2 ====",
 	"",
 	"\3Do you really want to start a new game [\1y\2/\1n\2]?",
 	NULL
 };
 
 const char ascii_shift[255] = {
 	['`'] = '~', ['1'] = '!', ['2'] = '@', ['3'] = '#', ['4'] = '$',
 	['5'] = '%', ['6'] = '^', ['7'] = '&', ['8'] = '*', ['9'] = '(',
 	['0'] = ')', ['-'] = '_', ['='] = '+',
 	
 	['q'] = 'Q', ['w'] = 'W', ['e'] = 'E', ['r'] = 'R', ['t'] = 'T',
 	['y'] = 'Y', ['u'] = 'U', ['i'] = 'I', ['o'] = 'O', ['p'] = 'P',
 	['['] = '{', [']'] = '}',
 
 	['a'] = 'A', ['s'] = 'S', ['d'] = 'D', ['f'] = 'F', ['g'] = 'G',
 	['h'] = 'H', ['j'] = 'J', ['k'] = 'K', ['l'] = 'L', [';'] = ':',
 	['\''] = '"',['\\'] = '|',
 
 	['z'] = 'Z', ['x'] = 'X', ['c'] = 'C', ['v'] = 'V', ['b'] = 'B',
 	['n'] = 'N', ['m'] = 'M', [','] = '<', ['.'] = '>', ['/'] = '?'
 };
 /* clang-format on */
 
 struct AnimationState {
 	SDL_FPoint start;
 	SDL_FPoint position;
 	SDL_FPoint end;
 	SDL_FPoint delta;
 	int active;
 	int step;
 	int final_step;
 };
 
 struct Cell {
 	int empty; /* logical variables */
 	int popping;
 	int path;
 	int starting;
 	int ending; /* logical variables end */
 	SDL_FPoint coords;
 	int contents;
 	struct Cell* down;
 	struct Cell* left;
 	struct Cell* right;
 	struct Cell* up;
 	struct Cell* path_next; /* next cell in shortest path */
 	struct Cell* path_prev; /* previous cell in shortest path */
 	int path_dist;		/* length of shortest path so far */
 };
 
 /* clang-format off */
 struct State {
 	struct AnimationState	animation;
 	SDL_Texture*		background;
 	struct Cell*		grid;
 	float			cell_scale_factor;
 	int			check_score;
 	SDL_Point		dialog_dims;
 	SDL_Point		dialog_text_origin;
 	int			dialog_shown;
 	const char**		dialog_text;
 	int			display_width; /* Physical, detected */
 	int			display_height;
 	int			full_screen;
 	struct HiScoreEntry*	hall_of_fame;
 	void			(*input_callback)(struct State*);
 	int			input_col;
 	int			input_instant_reset;
 	int 			input_shown;
 	int			location_pointer;
 	SDL_FPoint*		location_stack;
 	int			mode;
 	SDL_FPoint		mouse;
 	int			moveno;
 	int			nfree;
 	struct Cell*		path_start;
 	struct Cell*		path_end;
 	char			player_name[HI_SCORE_NAME_MAX];
 	int			player_name_length;
 	int			query_shown;
 	void			(*query_callback)(struct State*);
 	int			redraw;
 	SDL_Renderer*		renderer;
 	int			running;
 	int			screen_width; /* Logical */
 	int			screen_height;
 	unsigned long int	score;
 	SDL_FPoint		selection_start, selection_end;
 	SDL_Texture*		sprites;
 	SDL_Texture*		ter12_texture;
 	float			text_scale_factor;
 	SDL_Window*		window;
 };
 /* clang-format on */
 
 void add_cell(struct State* state, struct Cell* c, const int color,
 	const int index);
 void assign_pointFF(const SDL_FPoint* from, SDL_FPoint* to);
 void assign_pointIF(const SDL_Point* from, SDL_FPoint* to);
 void assign_point_xyIF(const int x, const int y, SDL_FPoint* to);
 void assign_point_xyII(const int x, const int y, SDL_Point* to);
 void calculate_delta(struct State* state);
 void calculate_grid_origin(const struct State* state, float* sx, float* sy);
 void calculate_display_size(struct State* state);
 int check_five(struct State* state, struct Cell* c);
 void cleanup(struct State* state);
 void do_exit(const int code, struct State* state);
 void draw(struct State* state);
 void erase_cell(struct State* state, struct Cell* c);
 void fill_triplet(struct State* state);
 int find_shortest_path(struct Cell* c, struct Cell* source, const int dist);
 void game_over(struct State* state);
 void game_over_dialog(struct State* state);
 void get_sprite_xy(const char cell, float* x, float* y);
 void grid_coord_to_screen_coord(const struct State* state, const int x,
 	const int y, const float startx, const float starty, float* to_x,
 	float* to_y);
 void grid_coord_to_screen_coordF(const struct State* state, const float x,
 	const float y, const float startx, const float starty, float* to_x,
 	float* to_y);
 void handle_click(struct State* state);
 void handle_event(struct State* state, SDL_Event* event);
 void handle_input(struct State* state, SDL_Event* event);
 void handle_key_down(struct State* state, SDL_Event* event);
 void init_cell(struct Cell* c, const int full, const SDL_FPoint* coords);
 void init_state(struct State* state);
 void input_name(struct State* state);
 void input_name_callback(struct State* state);
 int load_textures(struct State* state);
 void location_delete(struct State* state, const int index);
 int location_index(const struct State* state, const SDL_FPoint* location);
 void location_push(struct State* state, const SDL_FPoint* location);
 void mark_five(struct State* state, SDL_FPoint* start, SDL_FPoint* end);
 void mark_path(struct Cell* c);
 int num_size(const unsigned int num);
 void pop_strings(struct State* state);
 void prepare_dialog(struct State* state, const int w, const int h,
 	const char** text, const int dx, const int show);
 void prepare_hof_dialog(struct State* state, const int show);
 void print_matrix(const struct Cell* M);
 void print_path(struct Cell* c);
 void quit_callback(struct State* state);
 void really_quit(struct State* state);
 void render_background(struct State* state, SDL_FRect* bg_rect);
 void render_balls(struct State* state, const float startx, const float starty);
 void render_dialog(struct State* state);
 void render_selection(struct State* state, const float startx,
 	const float starty);
 void render_status(struct State* state);
 void render_text(struct State* state, const int x, const int y,
 	const int font_width, const int font_height, SDL_Texture* font_tex,
 	const char* text, ...);
 void repeat_char(char** s, const char ch, const int num_times);
 void reset(struct State* state);
 void reset_path(struct Cell* grid);
 void screen_coord_to_grid_coord(struct State* state, const int x, const int y,
 	const float startx, const float starty, float* to_x, float* to_y);
 void screen_coord_to_grid_coordF(struct State* state, const float x,
 	const float y, const float startx, const float starty, float* to_x,
 	float* to_y);
 void step_animation(struct State* state);
 int strlen_visible(const char* s);
 SDL_Texture* try_load(SDL_Renderer* renderer, const char* filename);
 
 void
 add_cell(struct State* state, struct Cell* c, const int color, const int index)
 {
 	assert((state != NULL) && (c != NULL));
 	c->contents = color;
 	c->empty    = 0;
 	state->nfree--;
 	location_delete(state, index);
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"add_cell: Cell at (%0.0f, %0.0f) is %s, "
 		"new location_pointer is %d",
 		c->coords.x, c->coords.y, cell_names[c->contents],
 		state->location_pointer);
 }
 
 void
 assign_pointFF(const SDL_FPoint* from, SDL_FPoint* to)
 {
 	assert((from != NULL) && (to != NULL));
 	to->x = from->x;
 	to->y = from->y;
 }
 
 void
 assign_pointIF(const SDL_Point* from, SDL_FPoint* to)
 {
 	assert((from != NULL) && (to != NULL));
 	to->x = (float)from->x;
 	to->y = (float)from->y;
 }
 
 void
 assign_point_xyIF(const int x, const int y, SDL_FPoint* to)
 {
 	assert(to != NULL);
 	to->x = (float)x;
 	to->y = (float)y;
 }
 
 void
 assign_point_xyII(const int x, const int y, SDL_Point* to)
 {
 	assert(to != NULL);
 	to->x = x;
 	to->y = y;
 }
 
 void
 calculate_delta(struct State* state)
 {
 	SDL_FPoint* start = NULL;
 	SDL_FPoint* end	  = NULL;
 	SDL_FPoint* delta = NULL;
 
 	assert(state != NULL);
 
 	start = &state->animation.start;
 	end   = &state->animation.end;
 	delta = &state->animation.delta;
 
 	delta->x = fabsf(end->x - start->x) / ANIM_STEPS;
 	if (end->x < start->x)
 		delta->x *= -1;
 	delta->y = fabsf(end->y - start->y) / ANIM_STEPS;
 	if (end->y < start->y)
 		delta->y *= -1;
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"calculate_delta: (%0.2f, %0.2f)", delta->x, delta->y);
 }
 
 void
 calculate_grid_origin(const struct State* state, float* sx, float* sy)
 {
 	int cx, cy;
 	float csf;
 
 	assert((state != NULL) && (sx != NULL) && (sy != NULL));
 
 	csf = state->cell_scale_factor;
 	cx  = state->screen_width / 2;
 	cy  = state->screen_height / 2;
 
 	*sx = cx - (csf * GRID_WIDTH * CELL_SIZE) / 2;
 	*sy = cy - (csf * GRID_HEIGHT * CELL_SIZE) / 2;
 }
 
 void
 calculate_display_size(struct State* state)
 {
 	assert(state != NULL);
 
 	if (!SDL_GetRenderOutputSize(state->renderer, &state->display_width,
 		    &state->display_height))
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_GetRenderOutputSize failed");
 		do_exit(1, state);
 	}
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"output display size: (%d, %d)", state->display_width,
 		state->display_height);
 }
 
 /* Returns: 0 if no strings, 1 if present */
 int
 check_five(struct State* state, struct Cell* c)
 {
 	SDL_FPoint start, end;
 	int x, y, len;
 	int i;
 	int found_string = 0;
 
 	assert((state != NULL) && (c != NULL));
 
 	i = 0;
 check_five_loop:
 	assign_pointFF(&c->coords, &start);
 	assign_pointFF(&c->coords, &end);
 	x = c->coords.x;
 	y = c->coords.y;
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Deltas: %d, %d",
 		check_five_deltas[i][0], check_five_deltas[i][1]);
 	len = 1;
 	while ((x >= 0 && y >= 0) && (x < GRID_WIDTH && y < GRID_HEIGHT))
 	{
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "At (%d, %d): %s", x,
 			y, cell_names[state->grid[INDEX(x, y)].contents]);
 		if (state->grid[INDEX(x, y)].contents == c->contents)
 		{
 			assign_point_xyIF(x, y, &start);
 			len++;
 		}
 		else
 			break;
 		x += check_five_deltas[i][0];
 		y += check_five_deltas[i][1];
 	}
 	x = c->coords.x + check_five_deltas[i][2];
 	y = c->coords.y + check_five_deltas[i][3];
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Deltas: %d, %d",
 		check_five_deltas[i][2], check_five_deltas[i][3]);
 	while ((x >= 0 && y >= 0) && (x < GRID_WIDTH && y < GRID_HEIGHT))
 	{
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "At (%d, %d): %s", x,
 			y, cell_names[state->grid[INDEX(x, y)].contents]);
 		if (state->grid[INDEX(x, y)].contents == c->contents)
 		{
 			assign_point_xyIF(x, y, &end);
 			len++;
 		}
 		else
 			break;
 		x += check_five_deltas[i][2];
 		y += check_five_deltas[i][3];
 	}
 	if (len > MIN_POP_LEN)
 	{
 		mark_five(state, &start, &end);
 		state->score += (len - 1) * POP_STRING_CELL_VALUE;
 		found_string = 1;
 	}
 	else
 	{
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"check_five: len = %d, not popping", len);
 	}
 	i++;
 	if (i < (ssize_t)(sizeof(check_five_deltas)
 		    / sizeof(check_five_deltas[0])))
 		goto check_five_loop;
 
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"check_five: nfree = %d < 3? %s", state->nfree,
 		state->nfree < 3 ? "TRUE" : "FALSE");
 
 	state->mode = STATE_IDLE;
 
 	return found_string;
 }
 
 void
 cleanup(struct State* state)
 {
 	assert(state != NULL);
 
 	free(state->location_stack);
 
 	if (state->background)
 		SDL_DestroyTexture(state->background);
 	if (state->ter12_texture)
 		SDL_DestroyTexture(state->ter12_texture);
 	if (state->sprites)
 		SDL_DestroyTexture(state->sprites);
 	if (state->renderer)
 		SDL_DestroyRenderer(state->renderer);
 	if (state->window)
 		SDL_DestroyWindow(state->window);
 
 	SDL_Quit();
 }
 
 void
 do_exit(const int code, struct State* state)
 {
 	cleanup(state);
 	exit(code);
 }
 
 void
 draw(struct State* state)
 {
 	SDL_FRect bg_rect;
 	SDL_FRect dest_rect;
 	float startx, starty;
 	float csf;
 
 	assert(state != NULL);
 	assert(state->cell_scale_factor != 0.0f);
 
 	csf = state->cell_scale_factor;
 	calculate_grid_origin(state, &startx, &starty);
 
 	bg_rect.x = 0;
 	bg_rect.y = 0;
 	bg_rect.w = csf * (CELL_SIZE * GRID_WIDTH + 1);
 	bg_rect.h = csf * (CELL_SIZE * GRID_HEIGHT + 1);
 
 	SDL_SetRenderDrawColor(state->renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
 	SDL_RenderClear(state->renderer);
 
 	/* Render background */
 	if (!state->background)
 		render_background(state, &bg_rect);
 
 	/* Draw buffered copy of background */
 	dest_rect.x = startx;
 	dest_rect.y = starty;
 	dest_rect.w = bg_rect.w;
 	dest_rect.h = bg_rect.h;
 	SDL_RenderTexture(state->renderer, state->background, &bg_rect,
 		&dest_rect);
 
 	/* Render balls */
 	render_balls(state, startx, starty);
 
 	/* Render selection */
 	if (state->selection_start.x != -1)
 		render_selection(state, startx, starty);
 
 	/* Render status */
 	render_status(state);
 
 	if (state->dialog_shown)
 		render_dialog(state);
 
 	/*render_text(600, screen_height - text_scale_factor * TER12_HEIGHT,
 		TER12_WIDTH, TER12_HEIGHT, ter12_texture, "(%05.2f, %05.2f)",
 		pointer.x, pointer.y);*/
 
 	SDL_RenderPresent(state->renderer);
 }
 
 void
 erase_cell(struct State* state, struct Cell* c)
 {
 	assert((state != NULL) && (c != NULL));
 	c->contents = CELL_EMPTY;
 	c->empty    = 1;
 	location_push(state, &c->coords);
 }
 
 void
 fill_triplet(struct State* state)
 {
 	struct Cell* c	= NULL;
 	SDL_FPoint* loc = NULL;
 	int idx;
 	int pass;
 	char color;
 
 	pass = 0;
 fill_triplet_generate:
 	if (state->location_pointer == 0)
 		goto fill_triplet_fail;
 	idx = random() % state->location_pointer;
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"fill_triplet: idx=%d/%d (%0.0f, %0.0f)", idx,
 		state->location_pointer, state->location_stack[idx].x,
 		state->location_stack[idx].y);
 	loc = &state->location_stack[idx];
 	c   = &state->grid[INDEXFI(loc->x, loc->y)];
 
 	/* Should never happen */
 	if (c->contents != CELL_EMPTY)
 	{
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"fill_triplet: Should not happen! Contents of cell "
 			"at (%0.0f, %0.0f) is %s",
 			c->coords.x, c->coords.y, cell_names[c->contents]);
 		do_exit(1, state);
 		goto fill_triplet_generate;
 	}
 
 	switch (random() % 5)
 	{
 	case 0:
 		color = CELL_RED;
 		break;
 	case 1:
 		color = CELL_BLUE;
 		break;
 	case 2:
 		color = CELL_GREEN;
 		break;
 	case 3:
 		color = CELL_PURPLE;
 		break;
 	default:
 		color = CELL_ORANGE;
 	}
 	add_cell(state, c, color, idx);
 	if (check_five(state, c))
 	{
 		pop_strings(state);
 		goto fill_triplet_generate;
 	}
 	/* Shouldn't happen */
 	if (state->nfree < 3)
 		goto fill_triplet_fail;
 	pass++;
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"fill_triplet: %s at (%0.0f, %0.0f)", cell_names[(int)color],
 		c->coords.x, c->coords.y);
 	if (pass < 3)
 		goto fill_triplet_generate;
 
 	return;
 
 fill_triplet_fail:
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"fill_triplet: input_instant_reset = %s",
 		state->input_instant_reset ? "TRUE" : "FALSE");
 	game_over(state);
 }
 
 int
 find_shortest_path(struct Cell* c, struct Cell* source, const int dist)
 {
 	int result = 0;
 
 	if (!c || c->path_dist <= dist)
 		return 0;
 
 	if (!c->empty && !c->starting && !c->ending)
 		return 0;
 
 	if (c->starting)
 		c->path_dist = dist;
 
 	if (c->path_dist > dist)
 	{
 		c->path_dist = dist;
 		c->path_prev = source;
 	}
 
 	if (c->ending)
 		return 1;
 
 	result |= find_shortest_path(c->left, c, dist + 1);
 	result |= find_shortest_path(c->up, c, dist + 1);
 	result |= find_shortest_path(c->right, c, dist + 1);
 	result |= find_shortest_path(c->down, c, dist + 1);
 
 	return result;
 }
 
 void
 game_over(struct State* state)
 {
 	assert(state != NULL);
 	state->mode = STATE_GAME_OVER;
 	if (state->check_score
 		&& state->score > state->hall_of_fame[HI_SCORE_MAX - 1].score)
 	{
 		state->check_score = 0;
 		input_name(state);
 	}
 	else
 	{
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"game_over: input_instant_reset = %s",
 			state->input_instant_reset ? "TRUE" : "FALSE");
 		if (state->input_instant_reset)
 		{
 			reset(state);
 			fill_triplet(state);
 			state->check_score	   = 1;
 			state->input_instant_reset = 0;
 		}
 		else
 			game_over_dialog(state);
 	}
 }
 
 void
 game_over_dialog(struct State* state)
 {
 	prepare_dialog(state, GAME_OVER_DIALOG_WIDTH, GAME_OVER_DIALOG_HEIGHT,
 		game_over_text, 0, 1);
 }
 
 void
 get_sprite_xy(const char cell, float* x, float* y)
 {
 	assert((x != NULL) && (y != NULL));
 	*x = sprite_positions[(int)cell].x;
 	*y = sprite_positions[(int)cell].y;
 }
 
 void
 grid_coord_to_screen_coord(const struct State* state, const int x, const int y,
 	const float startx, const float starty, float* to_x, float* to_y)
 {
 	assert((state != NULL) && (to_x != NULL) && (to_y != NULL));
 	*to_x = startx + x * state->cell_scale_factor * CELL_SIZE;
 	*to_y = starty + y * state->cell_scale_factor * CELL_SIZE;
 }
 
 void
 grid_coord_to_screen_coordF(const struct State* state, const float x,
 	const float y, const float startx, const float starty, float* to_x,
 	float* to_y)
 {
 	assert((state != NULL) && (to_x != NULL) && (to_y != NULL));
 	*to_x = startx + x * state->cell_scale_factor * CELL_SIZE;
 	*to_y = starty + y * state->cell_scale_factor * CELL_SIZE;
 }
 
 static char* cell_image[] = {"[ ]", "[R]", "[B]", "[G]", "[P]", "[O]", "[/]",
 	"[S]", "[E]", "[.]"};
 
 #define CELL_START 7
 #define CELL_END   8
 #define CELL_PATH  9
 
 void
 handle_click(struct State* state)
 {
 	float startx, starty;
 
 	assert(state != NULL);
 
 	if (state->dialog_shown)
 		return;
 
 	if (state->mode == STATE_IDLE)
 	{
 		calculate_grid_origin(state, &startx, &starty);
 		screen_coord_to_grid_coord(state, state->mouse.x,
 			state->mouse.y, startx, starty,
 			&state->selection_start.x, &state->selection_start.y);
 		state->animation.start.x    = (int)state->selection_start.x;
 		state->animation.start.y    = (int)state->selection_start.y;
 		state->animation.position.x = state->animation.start.x;
 		state->animation.position.y = state->animation.start.y;
 		state->path_start
 			= &state->grid[INDEXFI(state->animation.start.x,
 				state->animation.start.y)];
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"path_start(%0.2f, %0.2f)->empty = %s",
 			state->path_start->coords.x,
 			state->path_start->coords.y,
 			state->path_start->empty ? "TRUE" : "FALSE");
 		if (state->path_start->empty)
 		{
 			state->path_start	 = NULL;
 			state->selection_start.x = -1;
 			state->selection_start.y = -1;
 			return;
 		}
 
 		state->mode		    = STATE_SELECTION;
 		state->path_start->starting = 1;
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"[origin = (%0.2f, %0.2f)] "
 			"mouse = (%0.2f, %0.2f) => "
 			"selected = (%0.2f, %0.2f)",
 			startx, starty, state->mouse.x, state->mouse.y,
 			state->selection_start.x, state->selection_start.y);
 		state->redraw = 1;
 	}
 	else if (state->mode == STATE_SELECTION)
 	{
 		state->mode = STATE_MOVING;
 		calculate_grid_origin(state, &startx, &starty);
 		screen_coord_to_grid_coord(state, state->mouse.x,
 			state->mouse.y, startx, starty, &state->selection_end.x,
 			&state->selection_end.y);
 		state->path_end = &state->grid[INDEXFI(state->selection_end.x,
 			state->selection_end.y)];
 
 		assert((state->path_start != NULL) && (state->path_end != NULL));
 		if (!state->path_end->empty)
 			goto handle_click_reset;
 
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"[origin = (%0.2f, %0.2f)] "
 			"mouse = (%0.2f, %0.2f) => "
 			"selected_end = (%0.2f, %0.2f)",
 			startx, starty, state->mouse.x, state->mouse.y,
 			state->selection_end.x, state->selection_end.y);
 
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"Path: (%0.0f, %0.0f) to (%0.0f, %0.0f)",
 			state->path_start->coords.x,
 			state->path_start->coords.y, state->path_end->coords.x,
 			state->path_end->coords.y);
 		state->path_end->ending = 1;
 
 		if (!find_shortest_path(state->path_start, NULL, 0))
 		{
 			reset_path(state->grid);
 			goto handle_click_reset;
 		}
 
 		mark_path(state->path_end);
 		printf("M =\n");
 		print_matrix(state->grid);
 
 		if (!state->path_start->path_next)
 			return;
 
 		state->animation.end.x = state->path_start->path_next->coords.x;
 		state->animation.end.y = state->path_start->path_next->coords.y;
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"Animation: (%0.0f, %0.0f) to (%0.0f, %0.0f)",
 			state->animation.start.x, state->animation.start.y,
 			state->animation.end.x, state->animation.end.y);
 		state->selection_start.x = -1;
 		state->selection_start.y = -1;
 		calculate_delta(state);
 		state->animation.step	    = 1;
 		state->animation.final_step = ANIM_STEPS;
 		state->animation.active	    = 1;
 		state->redraw		    = 1;
 		print_path(&state->grid[INDEXFI(state->animation.start.x,
 			state->animation.start.y)]);
 	}
 	return;
 
 handle_click_reset:
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "handle_click: Reset");
 	state->selection_start.x    = -1;
 	state->selection_start.y    = -1;
 	state->path_start->starting = 0;
 	state->path_start	    = NULL;
 	state->path_end->ending	    = 0;
 	state->path_end		    = NULL;
 	state->mode		    = STATE_IDLE;
 	state->redraw		    = 1;
 }
 
 void
 handle_event(struct State* state, SDL_Event* event)
 {
 	/* assert(3) within the SDL_PollEvent(3) loop hangs the entire system
 	 * when given an argument which evaluates to zero, so we are taking the
 	 * risk of not using assert(3) here (and only here) */
 	/*assert((state != NULL) && (event != NULL));*/
 
 	switch (event->type)
 	{
 	case SDL_EVENT_QUIT:
 		state->running = 0;
 		break;
 	case SDL_EVENT_WINDOW_EXPOSED:
 		state->redraw = 1;
 		break;
 	case SDL_EVENT_WINDOW_RESIZED:
 		state->redraw = 1;
 		calculate_display_size(state);
 		break;
 	case SDL_EVENT_KEY_DOWN:
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"handle_event (before): player = {%s} [%d]",
 			state->player_name, state->player_name_length);
 		handle_key_down(state, event);
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"handle_event (after): player = {%s} [%d]",
 			state->player_name, state->player_name_length);
 		break;
 	case SDL_EVENT_MOUSE_BUTTON_UP:
 		handle_click(state);
 		break;
 	case SDL_EVENT_MOUSE_MOTION:
 		state->mouse.x = event->motion.x;
 		state->mouse.y = event->motion.y;
 		break;
 	}
 }
 
 void
 handle_input(struct State* state, SDL_Event* event)
 {
 	int i;
 
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"handle_input (before): state->player_name = {%s} [%d], %d",
 		state->player_name, state->player_name_length,
 		state->input_col);
 	switch (event->key.key)
 	{
 	case SDLK_ESCAPE:
 		state->input_shown = 0;
 		game_over_dialog(state);
 		break;
 	case SDLK_RETURN:
 		state->input_shown = 0;
 		if (state->input_callback)
 			state->input_callback(state);
 		break;
 	case SDLK_BACKSPACE:
 		if (state->input_col == 0)
 			break;
 		for (i = state->input_col - 1; i < state->player_name_length;
 			i++)
 			state->player_name[i] = state->player_name[i + 1];
 		state->player_name_length--;
 		state->player_name[state->player_name_length] = 0;
 		state->input_col--;
 		state->redraw = 1;
 		break;
 	case SDLK_DELETE:
 		if (state->input_col == state->player_name_length)
 			break;
 		for (i = state->input_col; i < state->player_name_length; i++)
 			state->player_name[i] = state->player_name[i + 1];
 		state->player_name_length--;
 		state->player_name[state->player_name_length] = 0;
 		state->redraw				      = 1;
 		break;
 	case SDLK_LEFT:
 		if (state->input_col > 0)
 		{
 			state->input_col--;
 			state->redraw = 1;
 		}
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"SDLK_LEFT: player_name = {%s} [%d]",
 			state->player_name, state->player_name_length);
 		break;
 	case SDLK_RIGHT:
 		if (state->input_col < state->player_name_length)
 		{
 			state->input_col++;
 			state->redraw = 1;
 		}
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"SDLK_RIGHT: player_name = {%s} [%d]",
 			state->player_name, state->player_name_length);
 		break;
 	case SDLK_HOME:
 		state->input_col = 0;
 		state->redraw	 = 1;
 		break;
 	case SDLK_END:
 		state->input_col = state->player_name_length;
 		state->redraw	 = 1;
 		break;
 	default:
 		if (event->key.key == SDLK_A && event->key.mod & SDL_KMOD_CTRL)
 		{
 			state->input_col = 0;
 			state->redraw	 = 1;
 			break;
 		}
 		if (event->key.key == SDLK_E && event->key.mod & SDL_KMOD_CTRL)
 		{
 			state->input_col = state->player_name_length;
 			state->redraw	 = 1;
 			break;
 		}
 		if (event->key.key == SDLK_U && event->key.mod & SDL_KMOD_CTRL)
 		{
 			*state->player_name	  = 0;
 			state->player_name_length = 0;
 			state->input_col	  = 0;
 			state->redraw		  = 1;
 			break;
 		}
 
 		if (state->player_name_length < HI_SCORE_NAME_MAX
 			&& event->key.key >= SDLK_SPACE
 			&& event->key.key <= SDLK_TILDE)
 		{
 			for (i = state->player_name_length;
 				i > state->input_col; i--)
 				state->player_name[i]
 					= state->player_name[i - 1];
 			state->player_name[state->input_col++]
 				= event->key.mod & SDL_KMOD_SHIFT
 				? ascii_shift[event->key.key]
 				: (char)event->key.key;
 			state->player_name_length++;
 			state->player_name[state->player_name_length] = 0;
 			SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 				"handle_input: event->key.key = %d",
 				event->key.key);
 			SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 				"handle_input (after): state->player_name = "
 				"{%s} [%d], %d",
 				state->player_name, state->player_name_length,
 				state->input_col);
 			state->redraw = 1;
 		}
 	}
 }
 
 void
 handle_key_down(struct State* state, SDL_Event* event)
 {
 	if (state->input_shown)
 	{
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"handle_key_down (before): player = {%s} [%d]",
 			state->player_name, state->player_name_length);
 		handle_input(state, event);
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"handle_key_down (after): player = {%s} [%d]",
 			state->player_name, state->player_name_length);
 		return;
 	}
 
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"Got Keydown, key = %X, mod = %X", event->key.key,
 		event->key.mod);
 
 	switch (event->key.key)
 	{
 	case SDLK_F1:
 		if (event->key.mod & SDL_KMOD_CTRL)
 		{
 			game_over(state);
 			break;
 		}
 
 		if (state->dialog_shown)
 			break;
 		prepare_dialog(state, HELP_DIALOG_WIDTH, HELP_DIALOG_HEIGHT,
 			help_text, 0, 1);
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Dialog shown: %s",
 			state->dialog_shown ? "YES" : "NO");
 		break;
 	case SDLK_F2:
 		if (state->dialog_shown && state->dialog_text == help_text)
 			break;
 		state->input_instant_reset = 1;
 		game_over(state);
 		break;
 	case SDLK_F3:
 		if (state->dialog_shown)
 			break;
 		prepare_hof_dialog(state, 1);
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Dialog shown: %s",
 			state->dialog_shown ? "YES" : "NO");
 		break;
 	case SDLK_RETURN:
 		if (!(event->key.mod & SDL_KMOD_ALT))
 			break;
 		state->full_screen = !state->full_screen;
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"Set fullscreen state: %s",
 			state->full_screen ? "ON" : "OFF");
 		SDL_SetWindowFullscreen(state->window, state->full_screen);
 		SDL_SetWindowBordered(state->window, !state->full_screen);
 		break;
 	case SDLK_ESCAPE:
 		if (state->dialog_shown && state->mode == STATE_GAME_OVER)
 			break;
 		state->dialog_shown = 0;
 		state->dialog_text  = NULL;
 		state->query_shown  = 0;
 		// assign_point_xyII(-1, -1, &state->dialog_dims);
 		state->redraw = 1;
 		break;
 	case SDLK_Y:
 		if (state->query_shown)
 		{
 			state->dialog_shown = 0;
 			state->dialog_text  = NULL;
 			state->query_shown  = 0;
 			state->redraw	    = 1;
 			if (state->query_callback)
 				state->query_callback(state);
 		}
 		break;
 	case SDLK_N:
 		if (state->query_shown)
 		{
 			state->dialog_shown   = 0;
 			state->dialog_text    = NULL;
 			state->query_callback = NULL;
 			state->query_shown    = 0;
 			state->redraw	      = 1;
 		}
 		break;
 	case SDLK_Q:
 		if (event->key.mod & SDL_KMOD_CTRL)
 			really_quit(state);
 		// state->running = 0;
 		break;
 	default:
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"Handle keyboard event: switch fallthrough");
 	}
 }
 
 void
 init_animation(struct AnimationState* animation)
 {
 	assert(animation != NULL);
 	animation->start.x    = -1;
 	animation->start.y    = -1;
 	animation->position.x = -1;
 	animation->position.y = -1;
 	animation->end.x      = -1;
 	animation->end.y      = -1;
 	animation->delta.x    = 0;
 	animation->delta.y    = 0;
 	animation->active     = 0;
 	animation->step	      = 0;
 	animation->final_step = 0;
 }
 
 void
 init_cell(struct Cell* c, const int full, const SDL_FPoint* coords)
 {
 	assert(c != NULL);
 	c->empty    = 1;
 	c->starting = 0;
 	c->ending   = 0;
 	c->popping  = 0;
 	c->path	    = 0;
 	if (full)
 	{
 		assert(coords != NULL);
 		c->coords.x = coords->x;
 		c->coords.y = coords->y;
 		c->down = c->left = c->right = c->up = NULL;
 	}
 	c->contents  = CELL_EMPTY;
 	c->path_next = NULL;
 	c->path_prev = NULL;
 	c->path_dist = INT_MAX;
 }
 
 void
 init_state(struct State* state)
 {
 	assert(state != NULL);
 	init_animation(&state->animation);
 	state->background	 = NULL;
 	state->grid		 = NULL;
 	state->cell_scale_factor = CELL_SCALE_FACTOR;
 	state->check_score	 = 1;
 	assign_point_xyII(-1, -1, &state->dialog_dims);
 	assign_point_xyII(0, 0, &state->dialog_text_origin);
 	state->dialog_shown   = 0;
 	state->dialog_text    = NULL;
 	state->display_width  = DEFAULT_WIDTH;
 	state->display_height = DEFAULT_HEIGHT;
 	state->full_screen    = 1;
 	state->hall_of_fame   = NULL;
 	// state->hof_text		= NULL;
 	state->input_callback	   = NULL;
 	state->input_col	   = 0;
 	state->input_instant_reset = 0;
 	state->input_shown	   = 0;
 	state->location_pointer	   = 0;
 	state->location_stack	   = NULL;
 	state->mode		   = STATE_IDLE;
 	state->moveno		   = 1;
 	state->nfree		   = GRID_WIDTH * GRID_HEIGHT;
 	assign_point_xyIF(0, 0, &state->mouse);
 	state->path_start	  = NULL;
 	state->path_end		  = NULL;
 	state->player_name[0]	  = 0;
 	state->player_name_length = 0;
 	state->query_shown	  = 0;
 	state->query_callback	  = NULL;
 	state->redraw		  = 1;
 	state->renderer		  = NULL;
 	state->running		  = 1;
 	state->screen_width	  = DEFAULT_WIDTH;
 	state->screen_height	  = DEFAULT_HEIGHT;
 	state->score		  = 0;
 	assign_point_xyIF(-1, -1, &state->selection_start);
 	assign_point_xyIF(-1, -1, &state->selection_end);
 	state->sprites		 = NULL;
 	state->ter12_texture	 = NULL;
 	state->text_scale_factor = TEXT_SCALE_FACTOR;
 	state->window		 = NULL;
 }
 
 void
 input_name(struct State* state)
 {
 	state->input_shown	  = 1;
 	state->query_shown	  = 0;
 	state->input_col	  = 0;
 	state->player_name_length = 0;
 	state->player_name[0]	  = 0;
 	state->input_callback	  = &input_name_callback;
 	prepare_dialog(state, INPUT_WIDTH, INPUT_HEIGHT, name_text, 0, 1);
 }
 
 void
 input_name_callback(struct State* state)
 {
 	int i;
 	assert(state != NULL);
 	state->input_callback = NULL;
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"input_name_callback: player_name = %s", state->player_name);
 	for (i = 0; i < state->player_name_length; i++)
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "%d",
 			state->player_name[i]);
 	hs_add_now(&state->hall_of_fame, state->player_name,
 		state->player_name_length, state->score);
 
 	if (hs_write(state->hall_of_fame, hs_get_hofdir()))
 	{
 		state->running = 1;
 		return;
 	}
 
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"input_name_callback: input_instant_reset = %s",
 		state->input_instant_reset ? "TRUE" : "FALSE");
 	if (state->input_instant_reset)
 	{
 		reset(state);
 		fill_triplet(state);
 		state->check_score	   = 1;
 		state->input_instant_reset = 0;
 	}
 	else
 		game_over_dialog(state);
 }
 
 int
 load_textures(struct State* state)
 {
 	SDL_ScaleMode scale_mode = SDL_SCALEMODE_PIXELART;
 
 	assert(state != NULL);
 
 	state->sprites = try_load(state->renderer, SPRITES_PNG);
 	if (!state->sprites)
 		return -1;
 	SDL_SetTextureScaleMode(state->sprites, scale_mode);
 
 	state->ter12_texture = try_load(state->renderer, TER12_PNG);
 	if (!state->ter12_texture)
 		return -1;
 	SDL_SetTextureScaleMode(state->ter12_texture, scale_mode);
 
 	return 0;
 }
 
 void
 location_delete(struct State* state, const int index)
 {
 	assert(state != NULL);
 	if (state->location_pointer == 0 || index < 0
 		|| index >= state->location_pointer)
 		return;
 	assign_pointFF(&state->location_stack[state->location_pointer - 1],
 		&state->location_stack[index]);
 	state->location_pointer--;
 }
 
 int
 location_index(const struct State* state, const SDL_FPoint* location)
 {
 	SDL_FPoint* p = NULL;
 	int i;
 
 	assert((state != NULL) && (location != NULL));
 	for (i = 0; i < state->location_pointer; i++)
 	{
 		p = &state->location_stack[i];
 		if (p->x == location->x && p->y == location->y)
 			return i;
 	}
 	return -1;
 }
 
 void
 location_push(struct State* state, const SDL_FPoint* location)
 {
 	assert((state != NULL) && (location != NULL));
 	state->location_stack[state->location_pointer].x = location->x;
 	state->location_stack[state->location_pointer].y = location->y;
 	state->location_pointer++;
 }
 
 void
 mark_five(struct State* state, SDL_FPoint* start, SDL_FPoint* end)
 {
 	struct Cell* c = NULL;
 	float dx, dy, x, y;
 
 	assert((state != NULL) && (start != NULL) && (end != NULL));
 	assert(!((start->x == end->x) && (start->y == end->y)));
 
 	dx = end->x - start->x;
 	dy = end->y - start->y;
 	if (dx != 0.0f)
 		dx = dx / fabsf(dx);
 	if (dy != 0.0f)
 		dy = dy / fabsf(dy);
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"mark_five: String[%d], from (%0.0f, %0.0f) to (%0.0f, "
 		"%0.0f)",
 		(int)floor(
 			MAX(fabsf(end->x - start->x), fabsf(end->y - start->y)))
 			+ 1,
 		start->x, start->y, end->x, end->y);
 	x = start->x;
 	y = start->y;
 	do
 	{
 		c	   = &state->grid[INDEXFI(x, y)];
 		c->popping = 1;
 		x += dx;
 		y += dy;
 		/* clang-format off */
 	}
 	while (!((x == end->x + dx) && (y == end->y + dy)));
 	/* clang-format on */
 }
 
 void
 mark_path(struct Cell* c)
 {
 	if (!c)
 		return;
 
 	c->path = 1;
 	if (c->path_prev)
 	{
 		c->path_prev->path_next = c;
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"mark_path: Next of (%0.0f, %0.0f) is (%0.0f, %0.0f)",
 			c->path_prev->coords.x, c->path_prev->coords.y,
 			c->path_prev->path_next->coords.x,
 			c->path_prev->path_next->coords.y);
 	}
 	mark_path(c->path_prev);
 }
 
 int
 num_size(const unsigned int num)
 {
 	if (num > 999999999)
 		return 10;
 	if (num > 99999999)
 		return 9;
 	if (num > 9999999)
 		return 8;
 	if (num > 999999)
 		return 7;
 	if (num > 99999)
 		return 6;
 	if (num > 9999)
 		return 5;
 	if (num > 999)
 		return 4;
 	if (num > 99)
 		return 3;
 	if (num > 9)
 		return 2;
 	return 1;
 }
 
 void
 pop_strings(struct State* state)
 {
 	struct Cell* c = NULL;
 	int x, y;
 
 	assert(state != NULL);
 	for (y = 0; y < GRID_HEIGHT; y++)
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			c = &state->grid[INDEX(x, y)];
 			if (c->popping)
 			{
 				erase_cell(state, c);
 				state->nfree++;
 				c->popping = 0;
 			}
 		}
 }
 
 void
 prepare_dialog(struct State* state, const int w, const int h, const char** text,
 	const int dx, const int show)
 {
 	assert((state != NULL) && (text != NULL));
 
 	assign_point_xyII(w, h, &state->dialog_dims);
 	state->dialog_text_origin.x = dx;
 	state->dialog_text	    = text;
 	state->dialog_shown	    = show;
 	if (show)
 		state->redraw = 1;
 }
 
 #define HOF_SCORES_START_IDX 2
 
 void
 prepare_hof_dialog(struct State* state, const int show)
 {
 	struct HiScoreEntry* e = NULL;
 	static char** hof_text = NULL;
 	static int hof_size    = HI_SCORE_MAX + 2 + 2 + 1;
 	char* dots	       = NULL;
 	int i;
 	int hof_line_len = 0;
 
 	assert(state != NULL);
 	errno = 0;
 
 	if (!(dots = malloc(HOF_DIALOG_MAX_LINE_LEN + 1)))
 		goto prepare_hof_dialog_malloc_error;
 
 	/*if (hof_text)
 		for (i = 3; i < hof_size - 3; i++)
 			free(hof_text[i]);
 	free(hof_text);*/
 
 	if (!hof_text)
 	{
 		if (!(hof_text = calloc(hof_size, sizeof(char*))))
 			goto prepare_hof_dialog_malloc_error;
 
 		hof_text[0]	       = "\3==== \1HALL OF FAME\2 ====";
 		hof_text[1]	       = "";
 		hof_text[hof_size - 3] = "";
 		hof_text[hof_size - 2] = "\3Press \1Esc\2 to close";
 		hof_text[hof_size - 1] = NULL;
 	}
 
 	for (i = 0; i < HI_SCORE_MAX; i++)
 	{
 		if (!(hof_text[HOF_SCORES_START_IDX + i]))
 		{
 			if (!(hof_text[HOF_SCORES_START_IDX + i]
 				    = malloc(HOF_DIALOG_MAX_LINE_LEN + 1)))
 				goto prepare_hof_dialog_malloc_error;
 		}
 		e = &state->hall_of_fame[i];
 		repeat_char(&dots, '.',
 			HOF_DIALOG_MAX_LINE_LEN - 4 - e->name_len
 				- num_size(e->score) - 1 - TIMESTAMP_MAX - 1);
 
 		/* +4 is the number of special characters (the number of visible
 		 * characters remains HOF_DIALOG_MAX_LINE_LEN) */
 		hof_line_len = HOF_DIALOG_MAX_LINE_LEN + 5;
 
 		/* For the first HOF_STANDOUT_ENTRIES entries, the number of
 		 * special characters increases by 1 */
 		if (i < HOF_STANDOUT_ENTRIES)
 			hof_line_len++;
 
 		snprintf(hof_text[HOF_SCORES_START_IDX + i], hof_line_len,
 			"\4%2d. %s%s\4%s\2%s%lu %s%s", i + 1,
 			i < HOF_STANDOUT_ENTRIES ? "\1" : "\2", e->name, dots,
 			i < HOF_STANDOUT_ENTRIES ? "\1" : "", e->score,
 			i < HOF_STANDOUT_ENTRIES ? "\2" : "\4",
 			e->timestamp);
 
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"HOF[%d] = \"%s\" (%ld [vis=%d])\n", i,
 			hof_text[HOF_SCORES_START_IDX + i],
 			strlen(hof_text[HOF_SCORES_START_IDX + i]),
 			strlen_visible(hof_text[HOF_SCORES_START_IDX + i]));
 	}
 
 	prepare_dialog(state, HOF_DIALOG_WIDTH, HOF_DIALOG_HEIGHT,
 		(const char**)hof_text, HOF_DIALOG_TEXT_ORIGIN_X, show);
 
 	free(dots);
 	return;
 
 prepare_hof_dialog_malloc_error:
 	SDL_LogError(SDL_LOG_CATEGORY_ERROR, "malloc failed");
 	exit(1);
 }
 
 void
 print_matrix(const struct Cell* M)
 {
 	const struct Cell* c = NULL;
 	int x, y;
 
 	for (y = 0; y < GRID_HEIGHT; y++)
 	{
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			c = &M[INDEX(x, y)];
 			if (c->starting)
 				printf("%s", cell_image[CELL_START]);
 			else if (c->ending)
 				printf("%s", cell_image[CELL_END]);
 			else if (c->path)
 				printf("%s", cell_image[CELL_PATH]);
 			else if (!c->empty)
 				printf("%s", cell_image[c->contents]);
 			else
 				printf("%s", cell_image[CELL_EMPTY]);
 		}
 		printf("\n");
 	}
 }
 
 void
 print_path(struct Cell* c)
 {
 	printf("(%0.0f, %0.0f)", c->coords.x, c->coords.y);
 	if (c->path_next)
 	{
 		printf(" -> ");
 		print_path(c->path_next);
 	}
 	else
 		printf("\n");
 }
 
 void
 quit_callback(struct State* state)
 {
 	assert(state != NULL);
 	UNUSED(state);
 	state->query_callback = NULL;
 	state->running	      = 0;
 }
 
 void
 really_quit(struct State* state)
 {
 	assert(state != NULL);
 	state->query_shown    = 1;
 	state->query_callback = quit_callback;
 	prepare_dialog(state, QUIT_MSGBOX_WIDTH, QUIT_MSGBOX_HEIGHT,
 		quit_msgbox_text, 0, 1);
 }
 
 void
 render_background(struct State* state, SDL_FRect* bg_rect)
 {
 	const SDL_DisplayMode* mode;
 	SDL_FRect cell_rect, dest_rect;
 	SDL_DisplayID display;
 	int x, y;
 
 	assert((state != NULL) && (bg_rect != NULL));
 	assert(state->cell_scale_factor != 0.0f);
 
 	if ((display = SDL_GetDisplayForWindow(state->window)) == 0)
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_GetDisplayForWindow failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 
 	if ((mode = SDL_GetCurrentDisplayMode(display)) == NULL)
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_GetCurrentDisplayMode failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 
 	state->background = SDL_CreateTexture(state->renderer, mode->format,
 		SDL_TEXTUREACCESS_TARGET, bg_rect->w, bg_rect->h);
 	if (!state->background)
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_CreateTexture failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 	if (!SDL_SetRenderTarget(state->renderer, state->background))
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_SetRenderTarget failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 
 	dest_rect.w = state->cell_scale_factor * CELL_SIZE;
 	dest_rect.h = state->cell_scale_factor * CELL_SIZE;
 	get_sprite_xy(CELL_EMPTY, &cell_rect.x, &cell_rect.y);
 	cell_rect.w = CELL_SIZE;
 	cell_rect.h = CELL_SIZE;
 	for (y = 0; y < GRID_HEIGHT; y++)
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			grid_coord_to_screen_coord(state, x, y, 0.0f, 0.0f,
 				&dest_rect.x, &dest_rect.y);
 			dest_rect.x += state->cell_scale_factor;
 			dest_rect.y += state->cell_scale_factor;
 			SDL_RenderTexture(state->renderer, state->sprites,
 				&cell_rect, &dest_rect);
 		}
 
 	/* Draw upper border */
 	for (x = -1; x < GRID_WIDTH; x++)
 	{
 		grid_coord_to_screen_coord(state, x, -1, 0.0f, 0.0f,
 			&dest_rect.x, &dest_rect.y);
 		dest_rect.x += state->cell_scale_factor;
 		dest_rect.y += state->cell_scale_factor;
 		SDL_RenderTexture(state->renderer, state->sprites, &cell_rect,
 			&dest_rect);
 	}
 
 	/* Draw left border */
 	for (y = 0; y < GRID_WIDTH; y++)
 	{
 		grid_coord_to_screen_coord(state, -1, y, 0.0f, 0.0f,
 			&dest_rect.x, &dest_rect.y);
 		dest_rect.x += state->cell_scale_factor;
 		dest_rect.y += state->cell_scale_factor;
 		SDL_RenderTexture(state->renderer, state->sprites, &cell_rect,
 			&dest_rect);
 	}
 
 	SDL_SetRenderDrawBlendMode(state->renderer, SDL_BLENDMODE_NONE);
 	SDL_SetRenderDrawColor(state->renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
 
 	SDL_SetRenderTarget(state->renderer, NULL);
 }
 
 void
 render_balls(struct State* state, const float startx, const float starty)
 {
 	struct Cell* c = NULL;
 	SDL_FRect cell_rect, dest_rect;
 	float csf;
 	int x, y;
 
 	assert(state != NULL);
 	assert(state->cell_scale_factor != 0.0f);
 
 	csf	    = state->cell_scale_factor;
 	cell_rect.w = CELL_SIZE;
 	cell_rect.h = CELL_SIZE;
 	dest_rect.w = csf * CELL_SIZE;
 	dest_rect.h = csf * CELL_SIZE;
 	for (y = 0; y < GRID_HEIGHT; y++)
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			c = &state->grid[INDEX(x, y)];
 			if (c->contents == CELL_EMPTY)
 				continue;
 
 			get_sprite_xy(c->contents, &cell_rect.x, &cell_rect.y);
 			if (c->path)
 				grid_coord_to_screen_coord(state,
 					state->animation.position.x,
 					state->animation.position.y, startx + 1,
 					starty + 1, &dest_rect.x, &dest_rect.y);
 			else
 				grid_coord_to_screen_coord(state, x, y,
 					startx + 1, starty + 1, &dest_rect.x,
 					&dest_rect.y);
 			SDL_RenderTexture(state->renderer, state->sprites,
 				&cell_rect, &dest_rect);
 		}
 }
 
 /* state is not const because of renderer, etc */
 void
 render_dialog(struct State* state)
 {
 	const char** ptext = NULL;
 	SDL_FRect dialog_rect, input_rect, cursor_rect;
 	float tsf;
 	int w, h;
 	int sx, sy, dx, _sx;
 
 	assert(state != NULL);
 	assert(state->dialog_text != NULL);
 	assert(state->text_scale_factor != 0.0f);
 
 	ptext = state->dialog_text;
 	w     = state->dialog_dims.x;
 	h     = state->dialog_dims.y;
 	sx    = state->screen_width / 2 - w / 2;
 	sy    = state->screen_height / 2 - h / 2;
 	dx    = state->dialog_text_origin.x;
 	tsf   = state->text_scale_factor;
 
 	dialog_rect.x = sx;
 	dialog_rect.y = sy;
 	dialog_rect.w = w;
 	dialog_rect.h = h;
 
 	SDL_SetRenderDrawBlendMode(state->renderer, SDL_BLENDMODE_BLEND);
 	SDL_SetRenderDrawColor(state->renderer, 0, 0, 0, .75 * 255);
 	SDL_RenderFillRect(state->renderer, &dialog_rect);
 
 	SDL_SetRenderDrawBlendMode(state->renderer, SDL_BLENDMODE_NONE);
 	SDL_SetRenderDrawColor(state->renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
 	SDL_RenderRect(state->renderer, &dialog_rect);
 	SDL_SetRenderDrawColor(state->renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
 	dialog_rect.x--;
 	dialog_rect.y--;
 	dialog_rect.w += 2;
 	dialog_rect.h += 2;
 	SDL_RenderRect(state->renderer, &dialog_rect);
 	dialog_rect.x--;
 	dialog_rect.y--;
 	dialog_rect.w += 2;
 	dialog_rect.h += 2;
 	SDL_RenderRect(state->renderer, &dialog_rect);
 
 	while (*ptext)
 	{
 		_sx = sx + dx + tsf * (2 * TER12_WIDTH);
 		// SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "1. _sx=%d", _sx);
 		if (strchr(*ptext, CENTER_LINE))
 			_sx += w / 2 - dx
 				- tsf * TER12_WIDTH
 					* (2 + strlen_visible(*ptext) / 2);
 		// SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "2. _sx=%d", _sx);
 
 		render_text(state, _sx,
 			sy
 				+ (ptext - state->dialog_text + 1) * tsf
 					* (TER12_HEIGHT + 2),
 			TER12_WIDTH, TER12_HEIGHT, state->ter12_texture, "%s",
 			*ptext);
 		ptext++;
 	}
 
 	if (state->input_shown)
 	{
 		input_rect.w = tsf * TER12_WIDTH * (HI_SCORE_NAME_MAX + 2);
 		input_rect.h = tsf * TER12_HEIGHT;
 		input_rect.x = sx + w / 2
 			- tsf * TER12_WIDTH * HI_SCORE_NAME_MAX / 2;
 		input_rect.y = sy + h - tsf * 2 * TER12_HEIGHT;
 
 		cursor_rect.w = TER12_WIDTH;
 		cursor_rect.h = 3;
 
 		SDL_SetRenderDrawBlendMode(state->renderer, SDL_BLENDMODE_BLEND);
 		SDL_SetRenderDrawColor(state->renderer, 55, 55, 55, .75 * 255);
 		SDL_RenderFillRect(state->renderer, &input_rect);
 		_sx = input_rect.x + tsf * TER12_WIDTH;
 
 		render_text(state, _sx, input_rect.y, TER12_WIDTH, TER12_HEIGHT,
 			state->ter12_texture, "%s", state->player_name);
 
 		cursor_rect.x = _sx + tsf * TER12_WIDTH * state->input_col;
 		cursor_rect.y
 			= input_rect.y + tsf * TER12_HEIGHT - cursor_rect.h;
 		SDL_SetRenderDrawColor(state->renderer, 255, 255, 255,
 			SDL_ALPHA_OPAQUE);
 		SDL_RenderFillRect(state->renderer, &cursor_rect);
 	}
 }
 
 void
 render_selection(struct State* state, const float startx, const float starty)
 {
 	SDL_FRect cell_rect, dest_rect;
 	float csf;
 
 	assert(state != NULL);
 	assert(state->cell_scale_factor != 0.0f);
 
 	csf = state->cell_scale_factor;
 	get_sprite_xy(CELL_SELECTED, &cell_rect.x, &cell_rect.y);
 	cell_rect.w = CELL_SIZE;
 	cell_rect.h = CELL_SIZE;
 	grid_coord_to_screen_coord(state, state->selection_start.x,
 		state->selection_start.y, startx + 1, starty + 1, &dest_rect.x,
 		&dest_rect.y);
 	dest_rect.w = csf * CELL_SIZE;
 	dest_rect.h = csf * CELL_SIZE;
 	SDL_RenderTexture(state->renderer, state->sprites, &cell_rect,
 		&dest_rect);
 }
 
 void
 render_status(struct State* state)
 {
 	float h, tsf;
 	int maxw = 30;
 
 	assert(state != NULL);
 
 	h   = state->screen_height;
 	tsf = state->text_scale_factor;
 
 	render_text(state, 0, h - tsf * TER12_HEIGHT, TER12_WIDTH, TER12_HEIGHT,
 		state->ter12_texture, "Score: \1%u\2", state->score);
 	render_text(state, maxw * TER12_WIDTH, h - tsf * TER12_HEIGHT,
 		TER12_WIDTH, TER12_HEIGHT, state->ter12_texture,
 		"\1F1\2 = Help");
 	render_text(state, 2 * maxw * TER12_WIDTH, h - tsf * TER12_HEIGHT,
 		TER12_WIDTH, TER12_HEIGHT, state->ter12_texture, "Move: \1%u\2",
 		state->moveno);
 	render_text(state, 3 * maxw * TER12_WIDTH, h - tsf * TER12_HEIGHT,
 		TER12_WIDTH, TER12_HEIGHT, state->ter12_texture, "Free: \1%u\2",
 		state->nfree);
 	render_text(state, 4 * maxw * TER12_WIDTH, h - tsf * TER12_HEIGHT,
 		TER12_WIDTH, TER12_HEIGHT, state->ter12_texture,
 		"Status: \1%s\2", state_descriptions[state->mode]);
 }
 
 void
 render_text(struct State* state, const int x, const int y, const int font_width,
 	const int font_height, SDL_Texture* font_tex, const char* text, ...)
 {
 	char buf[PRINT_BUFSIZE];
 	va_list args;
 	const char* pbuf = NULL;
 	SDL_FRect source_rect;
 	SDL_FRect dest_rect;
 	float tsf;
 	int xstart	  = 0;
 	int ystart	  = 0;
 	int index	  = 0;
 	int chars_per_row = 0;
 	char first_char	  = ' ';
 	char last_char	  = '~';
 	float tex_w, tex_h;
 	float opacity = TEXT_OPACITY_NORMAL;
 
 	assert((state != NULL) && (font_tex != NULL) && (text != NULL));
 	assert(state->text_scale_factor != 0.0f);
 	assert(font_width != -1);
 
 	tsf = state->text_scale_factor;
 
 	va_start(args, text);
 	vsnprintf(buf, sizeof(buf), text, args);
 	va_end(args);
 
 	source_rect.w = font_width;
 	source_rect.h = font_height;
 
 	dest_rect.x = x;
 	dest_rect.y = y;
 	dest_rect.w = tsf * font_width;
 	dest_rect.h = tsf * font_height;
 
 	if (!SDL_GetTextureSize(font_tex, &tex_w, &tex_h))
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_GetTextureSize failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 
 	SDL_SetTextureBlendMode(font_tex, SDL_BLENDMODE_BLEND);
 
 	chars_per_row = tex_w / (font_width + 1);
 
 	pbuf = buf;
 	while (*pbuf)
 	{
 		if (*pbuf >= first_char && *pbuf <= last_char)
 		{
 			index = (int)(*pbuf - first_char);
 
 			xstart = 1 + index % chars_per_row * (font_width + 1);
 			ystart = 1 + index / chars_per_row * (font_height + 1);
 		}
 		else if (*pbuf == CENTER_LINE)
 		{
 			pbuf++;
 			continue;
 		}
 		else if (*pbuf == BOLD_START)
 		{
 			opacity = TEXT_OPACITY_BOLD;
 			pbuf++;
 			continue;
 		}
 		else if (*pbuf == BOLD_END)
 		{
 			opacity = TEXT_OPACITY_NORMAL;
 			pbuf++;
 			continue;
 		}
 		else if (*pbuf == DIM_START)
 		{
 			opacity = TEXT_OPACITY_DIM;
 			pbuf++;
 			continue;
 		}
 		else
 			break;
 
 		source_rect.x = xstart;
 		source_rect.y = ystart;
 
 		if (!SDL_SetTextureAlphaModFloat(font_tex, opacity))
 			SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 				"SDL_SetTextureAlphaModFloat is not supported");
 		SDL_RenderTexture(state->renderer, font_tex, &source_rect,
 			&dest_rect);
 
 		dest_rect.x += tsf * font_width;
 
 		pbuf++;
 	}
 }
 
 void
 repeat_char(char** s, const char ch, const int num_times)
 {
 	int i;
 	assert(s != NULL);
 	for (i = 0; i < num_times; i++)
 		(*s)[i] = ch;
 	(*s)[i] = 0;
 }
 
 void
 reset(struct State* state)
 {
 	struct Cell* c = NULL;
 	int x, y;
 
 	assert(state != NULL);
 	state->location_pointer = 0;
 	for (y = 0; y < GRID_HEIGHT; y++)
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			c	    = &state->grid[INDEX(x, y)];
 			c->contents = CELL_EMPTY;
 			c->empty    = 1;
 			c->popping  = 0;
 			location_push(state, &c->coords);
 		}
 
 	state->dialog_text	 = NULL;
 	state->dialog_shown	 = 0;
 	state->mode		 = STATE_IDLE;
 	state->moveno		 = 1;
 	state->nfree		 = GRID_WIDTH * GRID_HEIGHT;
 	state->score		 = 0;
 	state->selection_start.x = -1;
 	state->selection_start.y = -1;
 	state->selection_end.x	 = -1;
 	state->selection_end.y	 = -1;
 	state->animation.active	 = 0;
 	state->redraw		 = 1;
 }
 
 void
 reset_path(struct Cell* grid)
 {
 	struct Cell* c = NULL;
 	int x, y;
 
 	assert(grid != NULL);
 
 	for (y = 0; y < GRID_HEIGHT; y++)
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			c	     = &grid[INDEX(x, y)];
 			c->path_next = NULL;
 			c->path_prev = NULL;
 			c->path_dist = INT_MAX;
 			c->starting  = 0;
 			c->ending    = 0;
 			c->path	     = 0;
 		}
 }
 
 void
 screen_coord_to_grid_coord(struct State* state, const int x, const int y,
 	const float startx, const float starty, float* to_x, float* to_y)
 {
 	float _factor_x, _factor_y;
 	float _startx, _starty;
 	float csf;
 
 	assert(state != NULL);
 	assert((to_x != NULL) && (to_y != NULL)
 		&& (state->cell_scale_factor != 0.0f));
 	csf	  = state->cell_scale_factor;
 	_factor_x = (float)state->display_width / state->screen_width;
 	_factor_y = (float)state->display_height / state->screen_height;
 	_startx	  = startx * _factor_x;
 	_starty	  = starty * _factor_y;
 
 	/* clang-format off */
 	*to_x = x >= _startx
 		? (x < _startx + _factor_x * csf
 			  * CELL_SIZE * GRID_WIDTH
 			  ? (x - _startx) / (_factor_x * csf * CELL_SIZE)
 			  : GRID_WIDTH - 1)
 		: 0;
 	*to_y = y >= _starty
 		? (y < _starty + _factor_y * csf
 			  * CELL_SIZE * GRID_HEIGHT
 			  ? (y - _starty) / (_factor_y * csf * CELL_SIZE)
 			  : GRID_HEIGHT - 1)
 		: 0;
 	/* clang-format on */
 }
 
 void
 screen_coord_to_grid_coordF(struct State* state, const float x, const float y,
 	const float startx, const float starty, float* to_x, float* to_y)
 {
 	float _factor_x, _factor_y;
 	float _startx, _starty;
 	float csf;
 
 	assert(state != NULL);
 	assert((to_x != NULL) && (to_y != NULL)
 		&& (state->cell_scale_factor != 0.0f));
 	csf	  = state->cell_scale_factor;
 	_factor_x = (float)state->display_width / state->screen_width;
 	_factor_y = (float)state->display_height / state->screen_height;
 	_startx	  = startx * _factor_x;
 	_starty	  = starty * _factor_y;
 
 	/* clang-format off */
 	*to_x = x >= _startx
 		? (x < _startx + _factor_x * csf * CELL_SIZE * GRID_WIDTH
 			  ? (x - _startx) / (_factor_x * csf * CELL_SIZE)
 			  : GRID_WIDTH - 1)
 		: 0;
 	*to_y = y >= _starty
 		? (y < _starty + _factor_y * csf * CELL_SIZE * GRID_HEIGHT
 			  ? (y - _starty) / (_factor_y * csf * CELL_SIZE)
 			  : GRID_HEIGHT - 1)
 		: 0;
 	/* clang-format on */
 }
 
 void
 step_animation(struct State* state)
 {
 	struct Cell* from = NULL;
 	struct Cell* to	  = NULL;
 	int isx, isy, iex, iey;
 	int idx;
 
 	if (state->animation.step == state->animation.final_step)
 	{
 		isx  = (int)round(state->animation.start.x);
 		isy  = (int)round(state->animation.start.y);
 		iex  = (int)round(state->animation.end.x);
 		iey  = (int)round(state->animation.end.y);
 		from = &state->grid[INDEX(isx, isy)];
 		to   = &state->grid[INDEX(iex, iey)];
 
 		if (to->ending)
 		{
 			state->animation.active = 0;
 			SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 				"Ending node reached: (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 		}
 		else if (to->path_next)
 		{
 			state->animation.start.x    = state->animation.end.x;
 			state->animation.start.y    = state->animation.end.y;
 			state->animation.position.x = state->animation.start.x;
 			state->animation.position.y = state->animation.start.y;
 			state->animation.end.x	    = to->path_next->coords.x;
 			state->animation.end.y	    = to->path_next->coords.y;
 			SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 				"Next node on path: (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 			SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 				"Animation: (%0.0f, %0.0f) to (%0.0f, %0.0f)",
 				state->animation.start.x,
 				state->animation.start.y,
 				state->animation.end.x, state->animation.end.y);
 			calculate_delta(state);
 			state->animation.step = 1;
 		}
 		else
 		{
 			SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 				"End of path at (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 			state->animation.active = 0;
 		}
 
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"grid[%d][%d] = %d <-> grid[%d][%d] = %d", iey, iex,
 			to->contents, isy, isx, from->contents);
 		idx = location_index(state, &to->coords);
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"location_index: Index of (%0.0f, %0.0f) is %d",
 			to->coords.x, to->coords.y, idx);
 		assert(idx != -1);
 		location_delete(state, idx);
 		location_push(state, &from->coords);
 		to->contents   = from->contents;
 		from->contents = CELL_EMPTY;
 		to->empty      = 0;
 		from->empty    = 1;
 
 		if (to->ending)
 		{
 			reset_path(state->grid);
 			state->path_start = NULL;
 			state->path_end	  = NULL;
 
 			if (check_five(state, to))
 				pop_strings(state);
 			else if (state->nfree < 3)
 				game_over(state);
 			else
 				fill_triplet(state);
 			state->moveno++;
 		}
 	}
 
 	state->animation.position.x += state->animation.delta.x;
 	state->animation.position.y += state->animation.delta.y;
 	state->animation.step++;
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 		"step_animation: (%0.2f, %0.2f) => (%0.2f, %0.2f), [%d/%d] %s",
 		state->animation.position.x, state->animation.position.y,
 		state->animation.end.x, state->animation.end.y,
 		state->animation.step, state->animation.final_step,
 		state->animation.active ? "ACTIVE" : "INACTIVE");
 }
 
 int
 strlen_visible(const char* s)
 {
 	int result     = 0;
 	const char* ps = NULL;
 
 	assert(s != NULL);
 	ps = s;
 	while (*ps)
 	{
 		if (*ps != CENTER_LINE && *ps != BOLD_START && *ps != BOLD_END
 			&& *ps != DIM_START)
 			result++;
 		ps++;
 	}
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "strlen_visible(%s)=%d\n", s,
 		result);
 	return result;
 }
 
 SDL_Texture*
 try_load(SDL_Renderer* renderer, const char* filename)
 {
 	SDL_Texture* tex = NULL;
 	char tex_pathname[BUFSIZE];
 
 	assert((renderer != NULL) && (filename != NULL));
 	snprintf(tex_pathname, BUFSIZE, "%s/%s", DATADIR, filename);
 	tex = IMG_LoadTexture(renderer, tex_pathname);
 	if (!tex)
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"try_load: IMG_LoadTexture failed: %s", SDL_GetError());
 		snprintf(tex_pathname, BUFSIZE, "./%s", filename);
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"try_load: trying %s", tex_pathname);
 		tex = IMG_LoadTexture(renderer, tex_pathname);
 		if (!tex)
 		{
 			SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 				"try_load: IMG_LoadTexture failed: %s",
 				SDL_GetError());
 			exit(1);
 		}
 		SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION,
 			"try_load: success (%s)", tex_pathname);
 	}
 
 	return tex;
 }
 
 int
 main(int argc, char** argv)
 {
 	SDL_Event event;
 	struct Cell* c = NULL;
 	struct State state;
 	struct HiScoreEntry* hof = NULL;
 	// struct HiScoreEntry* p	 = NULL;
 	struct timespec now;
 	SDL_FPoint coords;
 	float px, py;
 	clockid_t cid;
 	unsigned int last_time, current_time;
 	int x, y;
 
 	UNUSED(argc);
 	UNUSED(argv);
 
 	tzset();
 	init_state(&state);
 	hs_init(&hof);
 	if (hs_load(&hof, hs_get_hofdir()))
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "hs_load: %s",
 			strerror(errno));
 		exit(1);
 	}
 
 	state.hall_of_fame = hof;
 
 	if (!SDL_Init(SDL_INIT_VIDEO))
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SDL_Init failed: %s",
 			SDL_GetError());
 		exit(1);
 	}
 
 	SDL_SetLogPriorities(SDL_LOG_PRIORITY_DEBUG);
 	if (!SDL_CreateWindowAndRenderer(WIN_TITLE, DEFAULT_WIDTH,
 		    DEFAULT_HEIGHT,
 		    SDL_WINDOW_FULLSCREEN | SDL_WINDOW_BORDERLESS,
 		    &state.window, &state.renderer))
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR,
 			"SDL_CreateWindowAndRenderer failed: %s",
 			SDL_GetError());
 		do_exit(1, &state);
 	}
 
 	SDL_SetHintWithPriority(SDL_HINT_RENDER_VSYNC, "1", SDL_HINT_OVERRIDE);
 	SDL_SetRenderLogicalPresentation(state.renderer, DEFAULT_WIDTH,
 		DEFAULT_HEIGHT, SDL_LOGICAL_PRESENTATION_LETTERBOX);
 
 	calculate_display_size(&state);
 
 	state.grid = malloc(sizeof(struct Cell) * GRID_WIDTH * GRID_HEIGHT + 1);
 	if (!state.grid)
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "malloc failed");
 		do_exit(1, &state);
 	}
 	state.location_stack = malloc(sizeof(SDL_FPoint) * LOCATION_STACK_MAX);
 	if (!state.location_stack)
 	{
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "malloc failed");
 		do_exit(1, &state);
 	}
 	for (y = 0; y < GRID_HEIGHT; y++)
 		for (x = 0; x < GRID_WIDTH; x++)
 		{
 			c	 = &state.grid[INDEX(x, y)];
 			coords.x = x;
 			coords.y = y;
 			init_cell(c, 1, &coords);
 			location_push(&state, &c->coords);
 			if (x > 0)
 				c->left = &state.grid[INDEX(x - 1, y)];
 			if (y > 0)
 				c->up = &state.grid[INDEX(x, y - 1)];
 			if (x < GRID_WIDTH - 1)
 				c->right = &state.grid[INDEX(x + 1, y)];
 			if (y < GRID_HEIGHT - 1)
 				c->down = &state.grid[INDEX(x, y + 1)];
 		}
 
 	if (load_textures(&state) < 0)
 		do_exit(1, &state);
 
 	SDL_GetMouseState(&px, &py);
 	assign_point_xyIF(px, py, &state.mouse);
 
 	last_time = SDL_GetTicks();
 	clock_getcpuclockid(getpid(), &cid);
 	clock_gettime(cid, &now);
 	srandom(now.tv_nsec);
 
 	fill_triplet(&state);
 	while (state.running)
 	{
 		current_time = SDL_GetTicks();
 		if (state.animation.active)
 		{
 			if (current_time > last_time + 1000 / FPS)
 			{
 				draw(&state);
 				step_animation(&state);
 				last_time = current_time;
 			}
 			if (!state.animation.active)
 				draw(&state);
 		}
 		else if (state.redraw)
 		{
 			state.redraw = 0;
 			draw(&state);
 		}
 
 /* For some reason, SDL_RenderPresent is not enough for MSYS2/Windoze...
  * When moving a ball, the state of the screen remains stuck at the next-to-last
  * cell, until a mouse is moved, then it updates. This is a duct tape fix.
  */
 /* 2026-08-28: Probably a result of needing to respond to
  * SDL_EVENT_WINDOW_EXPOSED. Trying with that, now only to find a test machine
  * with MSYS2...
  */ 
 /*#if __WIN32
 		draw(&state);
 #endif*/
 
 		while (SDL_PollEvent(&event))
 			handle_event(&state, &event);
 	}
 
 	return 0;
 }