lav-sdl

lav-sdl.c (47324B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2023-2026  Strahinya Radich.
  * See the file LICENSE for exact copyright and license details. */
 
 #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 "local.h"
 
 #define ANIM_SPEED                                           \
 	100 /* how long does it take for the animation to go \
 	     * from start to finish (ms) */
 #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   1.0f
 #define BUFSIZE		    4096
 #define CELL_SIZE	    32
 #define DEFAULT_WIDTH	    1280
 #define DEFAULT_HEIGHT	    720
 #define HELP_DIALOG_WIDTH   900
 #define HELP_DIALOG_HEIGHT  450
 #define LABYRINTH_MAXHEIGHT 20
 #define LABYRINTH_MAXWIDTH  40
 #define LOCATION_STACK_MAX  (LABYRINTH_MAXWIDTH * LABYRINTH_MAXHEIGHT)
 #define PRINT_BUFSIZE	    4096
 #define PROGNAME	    "lav-sdl"
 #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	    "Lavirint (SDL version)"
 
 #define MIN(a, b)     (((a) < (b)) ? (a) : (b))
 #define MAX(a, b)     (((a) > (b)) ? (a) : (b))
 #define INDEX(x, y)   ((y) * state->grid_width + (x))
 #define INDEXFI(x, y) (((int)floor(y)) * state->grid_width + ((int)floor(x)))
 
 /* clang-format off */
 enum {
 	CELL_EMPTY,
 	CELL_WALL,
 	CELL_FAIL,
 	CELL_OK,
 	CELL_START,
 	CELL_END,
 	CELL_PATH
 };
 
 static char* cell_image[] = {"[ ]", "[H]", "[/]", "[o]", "[>]", "[v]", "[.]"};
 
 enum {
 	STATE_SEARCHING,
 	STATE_SEARCHING_PAUSED,
 	STATE_FAILURE,
 	STATE_SUCCESS
 };
 
 const char* state_descriptions[] = {
 	"Searching for exit",
 	"Searching (paused)",
 	"Failed!",
 	"Success!"
 };
 
 const char* help_text[] = {
 	"\1\3lav-sdl - SDL maze solver\2",
 	"\1\3=========================\2",
 	"",
 	"\1F1\2     - Show this help screen",
 	"\1Esc\2    - Hide this help screen",
 	"\1Space\2  - Pause/resume simulation",
 	"\1C-Q\2    - Exit",
 	"",
 	"\4---\2",
 	"",
 	"\4This program is licensed under the terms of GNU GPL v3 or (at your\2",
 	"\4option) any later version. Copyright (C) 2023-2026  Strahinya Radich.\2",
 	"\4See the file LICENSE for exact copyright and license details.\2",
 	NULL
 };
 /* 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;
 	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 Cell*		grid;
 	int			grid_height;
 	int			grid_width;
 	struct HiScoreEntry*	hall_of_fame;
 	SDL_Point		hero, start, end;
 	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;
 	struct Cell*		path_start;
 	struct Cell*		path_end;
 	SDL_FPoint		pointer;
 	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;
 	int			search_shortest;
 	SDL_FPoint		selection_start, selection_end;
 	SDL_Texture*		sprites;
 	int			state;
 	SDL_Texture*		ter12_texture;
 	float			text_scale_factor;
 	SDL_Window*		window;
 };
 
 /* clang-format on */
 
 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_display_size(struct State* state);
 void calculate_grid_origin(const struct State* state, float* sx, float* sy);
 void cleanup(struct State* state);
 void do_exit(const int code, struct State* state);
 void draw(struct State* state);
 int find_shortest_path(struct Cell* c, struct Cell* source, const int dist);
 void get_hero_sprite_xy(struct State* state, float* x, float* y);
 void get_sprite_xy(const int cell, float* x, float* 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 grid_coord_to_screen_coordI(const struct State* state, const int x,
 	const int y, const float startx, const float starty, float* to_x,
 	float* to_y);
 void handle_event(struct State* state, SDL_Event* event);
 void handle_key_down(struct State* state, SDL_Event* event);
 void init_animation(struct AnimationState* animation);
 void init_cell(struct Cell* c, const int full, const SDL_FPoint* coords);
 void init_state(struct State* state);
 void labyrinth_coord_to_screen_coordF(const float x, const float y,
 	const float startx, const float starty, float* to_x, float* to_y);
 void labyrinth_coord_to_screen_coordI(const int x, const int y,
 	const float startx, const float starty, float* to_x, float* to_y);
 int load_labyrinth(struct State* state, const char* pathname);
 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);
 int location_pop(struct State* state, SDL_Point* location);
 void location_pushF(struct State* state, const SDL_FPoint* location);
 void location_pushI(struct State* state, const SDL_Point* location);
 void mark_path(struct Cell* c);
 void next_step(struct State* state);
 int passable(struct State* state, const int x, const int y);
 int point_equalI(struct SDL_Point* p1, struct SDL_Point* p2);
 void prepare_dialog(struct State* state, const int w, const int h,
 	const char** text, const int dx, const int show);
 void print_debug(const char* fmt, ...);
 void print_error(const char* fmt, ...);
 void print_matrix(const struct State* state);
 void print_path(struct Cell* c);
 void render_background(struct State* state, SDL_FRect* bg_rect);
 void render_dialog(struct State* state);
 void render_hero(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 render_things(struct State* state, const float startx, const float starty);
 void reset(struct State* state);
 void reset_path(struct State* state);
 void step_animation(struct State* state);
 int strlen_visible(const char* s);
 SDL_Texture* try_load(SDL_Renderer* renderer, const char* filename);
 
 void
 assign_pointFF(const SDL_FPoint* from, SDL_FPoint* to)
 {
 	assert((from != NULL) && (to != NULL));
 	to->x = (float)from->x;
 	to->y = (float)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 = (float)x;
 	to->y = (float)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;
 
 	print_debug(
 		"calculate_delta: start: (%0.2f, %0.2f), end: (%0.2f, %0.2f)",
 		start->x, start->y, end->x, end->y);
 
 	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;
 	print_debug("calculate_delta: (%0.2f, %0.2f)", delta->x, delta->y);
 }
 
 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);
 	}
 	print_debug("output display size: (%d, %d)", state->display_width,
 		state->display_height);
 }
 
 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 * state->grid_width * CELL_SIZE) / 2;
 	*sy = cy - (csf * state->grid_height * CELL_SIZE) / 2;
 }
 
 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 * state->grid_width + 1);
 	bg_rect.h = csf * (CELL_SIZE * state->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 things */
 	render_things(state, startx, starty);
 
 	/* Render hero */
 	render_hero(state, startx, starty);
 
 	/* Render status */
 	render_status(state);
 
 	if (state->dialog_shown)
 		render_dialog(state);
 
 	SDL_RenderPresent(state->renderer);
 }
 
 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
 get_hero_sprite_xy(struct State* state, float* x, float* y)
 {
 	assert((state != NULL) && (x != NULL) && (y != NULL));
 
 	switch (state->state)
 	{
 	case STATE_SUCCESS:
 		*x = 1 + 4 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	case STATE_FAILURE:
 		*x = 1 + 6 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	default:
 		*x = 1 + 3 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	}
 }
 
 void
 get_sprite_xy(const int cell, float* x, float* y)
 {
 	switch (cell)
 	{
 	case CELL_START:
 		*x = 1 + 8 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	case CELL_END:
 		*x = 1 + 7 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	case CELL_WALL:
 		*x = 1;
 		*y = 1;
 		break;
 	case CELL_FAIL:
 		*x = 1 + 1 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	case CELL_OK:
 		*x = 1 + 2 * (CELL_SIZE + 1);
 		*y = 1;
 		break;
 	default:
 		*x = 1 + 5 * (CELL_SIZE + 1);
 		*y = 1;
 	}
 	/*print_debug("get_sprite_xy: %d @ (%0.0f, %0.0f)",
 		cell, *x, *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)
 {
 	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_coordI(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
 handle_event(struct State* state, SDL_Event* event)
 {
 	if (!event)
 		return;
 	switch (event->type)
 	{
 	case SDL_EVENT_QUIT:
 		state->running = 0;
 		break;
 	case SDL_EVENT_WINDOW_RESIZED:
 		state->redraw = 1;
 		calculate_display_size(state);
 		break;
 	case SDL_EVENT_KEY_DOWN:
 		print_debug("Got Keydown, key = %X, mod = %X", event->key.key,
 			event->key.mod);
 		handle_key_down(state, event);
 		break;
 	case SDL_EVENT_MOUSE_MOTION:
 		state->pointer.x = event->motion.x;
 		state->pointer.y = event->motion.y;
 		if (state->pointer.x <= 0 || state->pointer.y <= 0
 			|| state->pointer.x + 1 >= state->display_width
 			|| state->pointer.y + 1 >= state->display_height)
 			SDL_ShowCursor();
 		else
 			SDL_HideCursor();
 		break;
 	}
 }
 
 void
 handle_key_down(struct State* state, SDL_Event* event)
 {
 	switch (event->key.key)
 	{
 	case SDLK_F1:
 		if (state->dialog_shown)
 			break;
 		prepare_dialog(state, HELP_DIALOG_WIDTH, HELP_DIALOG_HEIGHT,
 			help_text, 0, 1);
 		break;
 	case SDLK_ESCAPE:
 		state->dialog_shown = 0;
 		state->dialog_text  = NULL;
 		state->redraw	    = 1;
 		break;
 	case SDLK_SPACE:
 		if (state->state == STATE_SEARCHING)
 		{
 			print_debug("State: paused");
 			state->state = STATE_SEARCHING_PAUSED;
 		}
 		else if (state->state == STATE_SEARCHING_PAUSED)
 		{
 			print_debug("State: searching");
 			state->state = STATE_SEARCHING;
 		}
 		else
 		{
 			print_debug("Resetting");
 			reset(state);
 		}
 		break;
 	case SDLK_Q:
 		if (event->key.mod & SDL_KMOD_CTRL)
 			state->running = 0;
 		break;
 	default:
 		print_debug("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->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->moveno		   = 1;
 	assign_point_xyIF(0, 0, &state->mouse);
 	state->path_start      = NULL;
 	state->path_end	       = NULL;
 	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;
 	state->search_shortest = 0;
 	assign_point_xyIF(-1, -1, &state->selection_start);
 	assign_point_xyIF(-1, -1, &state->selection_end);
 	state->sprites		 = NULL;
 	state->state		 = STATE_SEARCHING_PAUSED;
 	state->ter12_texture	 = NULL;
 	state->text_scale_factor = TEXT_SCALE_FACTOR;
 	state->window		 = NULL;
 }
 
 void
 labyrinth_coord_to_screen_coordF(const float x, const float y,
 	const float startx, const float starty, float* to_x, float* to_y)
 {
 	*to_x = startx + x * CELL_SIZE;
 	*to_y = starty + y * CELL_SIZE;
 }
 
 void
 labyrinth_coord_to_screen_coordI(const int x, const int y, const float startx,
 	const float starty, float* to_x, float* to_y)
 {
 	*to_x = startx + x * CELL_SIZE;
 	*to_y = starty + y * CELL_SIZE;
 }
 
 int
 load_labyrinth(struct State* state, const char* pathname)
 {
 	FILE* input    = NULL;
 	struct Cell* c = NULL;
 	SDL_FPoint coords;
 	int x, y;
 	int firstline = 1;
 
 	assert((state != NULL) && (pathname != NULL));
 
 	input = fopen(pathname, "rt");
 	if (!input)
 		return -1;
 
 	state->grid = malloc(
 		sizeof(struct Cell) * LABYRINTH_MAXWIDTH * LABYRINTH_MAXHEIGHT);
 	if (!state->grid)
 	{
 		print_error("malloc failed");
 		do_exit(1, state);
 	}
 	state->grid_width     = LABYRINTH_MAXWIDTH;
 	state->grid_height    = LABYRINTH_MAXHEIGHT;
 	state->location_stack = malloc(
 		sizeof(SDL_FPoint) * LABYRINTH_MAXWIDTH * LABYRINTH_MAXHEIGHT);
 	if (!state->location_stack)
 	{
 		print_error("malloc failed");
 		do_exit(1, state);
 	}
 
 	fscanf(input, "%d %d\n", &state->start.x, &state->start.y);
 	/* 1-based coordinates for compatibility */
 	state->start.x--;
 	state->start.y--;
 	fscanf(input, "%d %d\n", &state->end.x, &state->end.y);
 	state->end.x--;
 	state->end.y--;
 
 	x		   = 0;
 	y		   = 0;
 	state->grid_width  = 0;
 	state->grid_height = 0;
 	while (!feof(input))
 	{
 		char ch = fgetc(input);
 		if (ch == EOF)
 			continue;
 
 		if (strchr("01", ch))
 		{
 			if (x == LABYRINTH_MAXWIDTH || y == LABYRINTH_MAXHEIGHT)
 			{
 				print_error("Labyrinth overflow at %d, %d"
 					    " (ch == %c)",
 					x, y, ch);
 				do_exit(1, state);
 			}
 			c = &state->grid[INDEX(x, y)];
 
 			coords.x = x;
 			coords.y = y;
 			init_cell(c, 1, &coords);
 
 			c->contents = (ch == '0' ? CELL_EMPTY : CELL_WALL);
 			c->empty    = c->contents == CELL_EMPTY;
 			x++;
 			if (firstline)
 				state->grid_width++;
 		}
 		else if (ch == '\n')
 		{
 			x = 0;
 			y++;
 			firstline = 0;
 			state->grid_height++;
 		}
 		else if (strchr(" \r", ch))
 			/* Ignore CR for compatibility */;
 		else
 			print_debug("Unknown character in labyrinth file: '%c'"
 				    " = %X",
 				ch, ch);
 	}
 
 	for (y = 0; y < state->grid_height; y++)
 	{
 		for (x = 0; x < state->grid_width; x++)
 		{
 			c	    = &state->grid[INDEX(x, y)];
 			c->coords.x = x;
 			c->coords.y = y;
 
 			c->left = c->up = c->right = c->down = NULL;
 			if (x > 0)
 				c->left = &state->grid[INDEX(x - 1, y)];
 			if (y > 0)
 				c->up = &state->grid[INDEX(x, y - 1)];
 			if (x < state->grid_width - 1)
 				c->right = &state->grid[INDEX(x + 1, y)];
 			if (y < state->grid_height - 1)
 				c->down = &state->grid[INDEX(x, y + 1)];
 		}
 	}
 
 	state->hero.x = state->start.x;
 	state->hero.y = state->start.y;
 	state->grid[INDEX(state->start.x, state->start.y)].contents
 		= CELL_START;
 	state->grid[INDEX(state->start.x, state->start.y)].starting = 1;
 	state->grid[INDEX(state->end.x, state->end.y)].contents	    = CELL_END;
 	state->grid[INDEX(state->end.x, state->end.y)].ending	    = 1;
 
 	fclose(input);
 
 	return 0;
 }
 
 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;
 }
 
 int
 location_pop(struct State* state, SDL_Point* location)
 {
 	assert((state != NULL) && (location != NULL));
 	if (state->location_pointer == 0)
 		return 1;
 	state->location_pointer--;
 	location->x = state->location_stack[state->location_pointer].x;
 	location->y = state->location_stack[state->location_pointer].y;
 	return 0;
 }
 
 void
 location_pushF(struct State* state, const SDL_FPoint* location)
 {
 	assert((state != NULL) && (location != NULL));
 	assert(state->location_stack != NULL);
 	state->location_stack[state->location_pointer].x = location->x;
 	state->location_stack[state->location_pointer].y = location->y;
 	state->location_pointer++;
 }
 
 void
 location_pushI(struct State* state, const SDL_Point* 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_path(struct Cell* c)
 {
 	if (!c)
 		return;
 
 	c->path = 1;
 	if (c->path_prev)
 	{
 		c->path_prev->path_next = c;
 		print_debug(
 			"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);
 }
 
 void
 next_step(struct State* state)
 {
 	struct Cell* from = NULL;
 	struct Cell* to	  = NULL;
 	SDL_Point backup;
 	int isx, isy, iex, iey;
 	int idx;
 
 	if (!state->search_shortest)
 		goto next_step_brute_force;
 
 	if (!state->animation.active)
 	{
 		if (!state->path_end)
 		{
 			state->path_start = &state->grid[INDEX(state->start.x,
 				state->start.y)];
 			state->path_end
 				= &state->grid[INDEX(state->end.x, state->end.y)];
 			if (!find_shortest_path(state->path_start, NULL, 0))
 			{
 				reset_path(state);
 				state->path_start->contents = CELL_FAIL;
 				state->path_start	    = NULL;
 				state->path_end		    = NULL;
 				state->animation.active	    = 0;
 				state->state		    = STATE_FAILURE;
 				print_debug("find_shortest_path FAILED");
 				state->redraw = 1;
 				return;
 			}
 			print_debug(
 				"find_shortest_path successful, path len = %d",
 				state->path_end->path_dist);
 			mark_path(state->path_end);
 			print_debug("M = ");
 			print_matrix(state);
 			if (!state->path_start->path_next)
 				return;
 		}
 
 		state->animation.start.x = state->path_start->coords.x;
 		state->animation.start.y = state->path_start->coords.y;
 		state->animation.end.x = state->path_start->path_next->coords.x;
 		state->animation.end.y = state->path_start->path_next->coords.y;
 		state->animation.position.x = state->path_start->coords.x;
 		state->animation.position.y = state->path_start->coords.y;
 		print_debug("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;
 		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)]);
 	}
 
 	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;
 			print_debug("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;
 			print_debug("Next node on path: (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 			print_debug(
 				"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
 		{
 			print_debug("End of path at (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 			state->animation.active = 0;
 		}
 
 		print_debug("grid[%d][%d] = %d <-> grid[%d][%d] = %d", iey, iex,
 			to->contents, isy, isx, from->contents);
 		idx = location_index(state, &to->coords);
 		print_debug("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_pushF(state, &from->coords);
 
 		if (to->ending)
 		{
 			reset_path(state);
 			state->path_start = NULL;
 			state->path_end	  = NULL;
 		}
 	}
 
 	state->animation.position.x += state->animation.delta.x;
 	state->animation.position.y += state->animation.delta.y;
 	state->animation.step++;
 	print_debug(
 		"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");
 	return;
 
 next_step_brute_force:
 	if (state->hero.x == state->end.x && state->hero.y == state->end.y)
 	{
 		print_debug("next_step: Success");
 		state->state = STATE_SUCCESS;
 	}
 	else if (passable(state, state->hero.x - 1, state->hero.y))
 	{
 		print_debug("next_step: Trying x-1, y: (%d, %d), "
 			    "pushed to stack (%d, %d)",
 			state->hero.x - 1, state->hero.y, state->hero.x,
 			state->hero.y);
 		state->grid[INDEX(state->hero.x, state->hero.y)].contents
 			= CELL_OK;
 		location_pushI(state, &state->hero);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.start);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.position);
 		assign_point_xyIF(state->hero.x - 1, state->hero.y,
 			&state->animation.end);
 		calculate_delta(state);
 		state->animation.step	    = 1;
 		state->animation.final_step = ANIM_STEPS;
 		state->animation.active	    = 1;
 	}
 	else if (passable(state, state->hero.x, state->hero.y - 1))
 	{
 		print_debug("next_step: Trying x, y-1: (%d, %d), "
 			    "pushed to stack (%d, %d)",
 			state->hero.x, state->hero.y - 1, state->hero.x,
 			state->hero.y);
 		state->grid[INDEX(state->hero.x, state->hero.y)].contents
 			= CELL_OK;
 		location_pushI(state, &state->hero);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.start);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.position);
 		assign_point_xyIF(state->hero.x, state->hero.y - 1,
 			&state->animation.end);
 		calculate_delta(state);
 		state->animation.step	    = 1;
 		state->animation.final_step = ANIM_STEPS;
 		state->animation.active	    = 1;
 	}
 	else if (passable(state, state->hero.x + 1, state->hero.y))
 	{
 		print_debug("next_step: Trying x+1, y: (%d, %d), "
 			    "pushed to stack (%d, %d)",
 			state->hero.x + 1, state->hero.y, state->hero.x,
 			state->hero.y);
 		state->grid[INDEX(state->hero.x, state->hero.y)].contents
 			= CELL_OK;
 		location_pushI(state, &state->hero);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.start);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.position);
 		assign_point_xyIF(state->hero.x + 1, state->hero.y,
 			&state->animation.end);
 		calculate_delta(state);
 		state->animation.step	    = 1;
 		state->animation.final_step = ANIM_STEPS;
 		state->animation.active	    = 1;
 	}
 	else if (passable(state, state->hero.x, state->hero.y + 1))
 	{
 		print_debug("next_step: Trying x, y+1: (%d, %d), "
 			    "pushed to stack (%d, %d)",
 			state->hero.x, state->hero.y + 1, state->hero.x,
 			state->hero.y);
 		state->grid[INDEX(state->hero.x, state->hero.y)].contents
 			= CELL_OK;
 		location_pushI(state, &state->hero);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.start);
 		assign_point_xyIF(state->hero.x, state->hero.y,
 			&state->animation.position);
 		assign_point_xyIF(state->hero.x, state->hero.y + 1,
 			&state->animation.end);
 		calculate_delta(state);
 		state->animation.step	    = 1;
 		state->animation.final_step = ANIM_STEPS;
 		state->animation.active	    = 1;
 	}
 	else
 	{
 		/* Back up */
 		if (location_pop(state, &backup))
 		{
 			print_debug("State: failure");
 			state->state = STATE_FAILURE;
 		}
 		else
 		{
 			print_debug("Backing up, stack pop: %d, %d", backup.x,
 				backup.y);
 			state->grid[INDEX(state->hero.x, state->hero.y)].contents
 				= CELL_FAIL;
 			assign_pointIF(&state->hero, &state->animation.start);
 			assign_pointIF(&state->hero, &state->animation.position);
 			assign_pointIF(&backup, &state->animation.end);
 			calculate_delta(state);
 			state->animation.step	    = 1;
 			state->animation.final_step = ANIM_STEPS;
 			state->animation.active	    = 1;
 		}
 	}
 	state->redraw = 1;
 }
 
 int
 passable(struct State* state, const int x, const int y)
 {
 	return (x >= 0 && x < state->grid_width && y >= 0
 		&& y < state->grid_height
 		&& (state->grid[INDEX(x, y)].contents == CELL_EMPTY
 			|| state->grid[INDEX(x, y)].contents == CELL_END));
 }
 
 int
 point_equalI(struct SDL_Point* p1, struct SDL_Point* p2)
 {
 	assert((p1 != NULL) && (p2 != NULL));
 	return p1->x == p2->x && p1->y == p2->y;
 }
 
 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;
 }
 
 void
 print_debug(const char* fmt, ...)
 {
 	char buf[PRINT_BUFSIZE];
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(buf, sizeof(buf), fmt, args);
 	va_end(args);
 	SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "d: %s", buf);
 }
 
 void
 print_error(const char* fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	SDL_LogError(SDL_LOG_CATEGORY_ERROR, fmt, args);
 	va_end(args);
 }
 
 void
 print_matrix(const struct State* state)
 {
 	const struct Cell* c = NULL;
 	int x, y;
 
 	for (y = 0; y < state->grid_height; y++)
 	{
 		for (x = 0; x < state->grid_width; x++)
 		{
 			c = &state->grid[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("(%0.0f,%0.0f) ", c->coords.x, c->coords.y);
 			/*if (c->empty)
 				printf("E ");
 			else
 				printf("F ");*/
 		}
 		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
 render_background(struct State* state, SDL_FRect* bg_rect)
 {
 	const SDL_DisplayMode* mode;
 	SDL_FRect cell_rect, dest_rect;
 	SDL_DisplayID display;
 	float csf;
 	float crx, cry;
 	float drx, dry;
 	float sx, sy;
 	float ex, ey;
 	int x, y;
 
 	assert((state != NULL) && (bg_rect != NULL));
 	assert(state->cell_scale_factor != 0.0f);
 
 	csf = state->cell_scale_factor;
 	sx  = state->start.x;
 	sy  = state->start.y;
 	ex  = state->end.x;
 	ey  = state->end.y;
 
 	if ((display = SDL_GetDisplayForWindow(state->window)) == 0)
 	{
 		print_error("SDL_GetDisplayForWindow failed: %s",
 			SDL_GetError());
 		do_exit(1, state);
 	}
 
 	if ((mode = SDL_GetCurrentDisplayMode(display)) == NULL)
 	{
 		print_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)
 	{
 		print_error("SDL_CreateTexture failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 	if (!SDL_SetRenderTarget(state->renderer, state->background))
 	{
 		print_error("SDL_SetRenderTarget failed: %s", SDL_GetError());
 		do_exit(1, state);
 	}
 
 	SDL_SetRenderDrawColor(state->renderer, 0x22, 0x22, 0x22,
 		SDL_ALPHA_OPAQUE);
 	SDL_RenderFillRect(state->renderer, bg_rect);
 
 	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 < state->grid_height; y++)
 		for (x = 0; x < state->grid_width; x++)
 		{
 			if (!((state->grid[INDEX(x, y)].contents != CELL_OK
 				      && state->grid[INDEX(x, y)].contents
 					      != CELL_FAIL)
 				    || (x == sx && y == sy)
 				    || (x == ex && y == ey)))
 				continue;
 
 			get_sprite_xy(state->grid[INDEX(x, y)].contents, &crx,
 				&cry);
 			cell_rect.x = crx;
 			cell_rect.y = cry;
 			grid_coord_to_screen_coordI(state, x, y, 0.0f, 0.0f,
 				&drx, &dry);
 			dest_rect.x = drx;
 			dest_rect.y = dry;
 			SDL_RenderTexture(state->renderer, state->sprites,
 				&cell_rect, &dest_rect);
 		}
 
 	SDL_SetRenderTarget(state->renderer, NULL);
 }
 
 /* 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);
 		if (strchr(*ptext, CENTER_LINE))
 			_sx += w / 2 - dx
 				- tsf * TER12_WIDTH
 					* (2 + strlen_visible(*ptext) / 2);
 		render_text(state, _sx,
 			sy
 				+ (ptext - state->dialog_text + 1) * tsf
 					* (TER12_HEIGHT + 2),
 			TER12_WIDTH, TER12_HEIGHT, state->ter12_texture, "%s",
 			*ptext);
 		ptext++;
 	}
 }
 
 void
 render_hero(struct State* state, const float startx, const float starty)
 {
 	SDL_FRect dest_rect, cell_rect;
 	float csf;
 	float crx, cry;
 	float drx, dry;
 
 	assert(state != NULL);
 
 	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;
 	get_hero_sprite_xy(state, &crx, &cry);
 	cell_rect.x = crx;
 	cell_rect.y = cry;
 	if (state->animation.active)
 		labyrinth_coord_to_screen_coordF(state->animation.position.x,
 			state->animation.position.y, startx, starty, &drx,
 			&dry);
 	else
 		labyrinth_coord_to_screen_coordI(state->hero.x, state->hero.y,
 			startx, starty, &drx, &dry);
 	dest_rect.x = drx;
 	dest_rect.y = dry;
 	SDL_RenderTexture(state->renderer, state->sprites, &cell_rect,
 		&dest_rect);
 }
 
 void
 render_status(struct State* state)
 {
 	render_text(state, 0,
 		state->screen_height - state->text_scale_factor * TER12_HEIGHT,
 		TER12_WIDTH, TER12_HEIGHT, state->ter12_texture,
 		"Column: \1%2d\2,  Row: \1%2d\2"
 		"    \1F1\2 = Help"
 		"    Status: \1%s\2",
 		state->hero.x + 1, state->hero.y + 1,
 		state_descriptions[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, ...)
 {
 	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((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
 render_things(struct State* state, const float startx, const float starty)
 {
 	SDL_FRect cell_rect, dest_rect;
 	int x, y;
 	float csf;
 	float crx, cry;
 	float drx, dry;
 
 	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 < state->grid_height; y++)
 		for (x = 0; x < state->grid_width; x++)
 		{
 			if ((state->grid[INDEX(x, y)].contents != CELL_OK
 				    && state->grid[INDEX(x, y)].contents
 					    != CELL_FAIL)
 				|| (x == state->start.x && y == state->start.y)
 				|| (x == state->end.x && y == state->end.y))
 				continue;
 
 			get_sprite_xy(state->grid[INDEX(x, y)].contents, &crx,
 				&cry);
 			cell_rect.x = crx;
 			cell_rect.y = cry;
 			labyrinth_coord_to_screen_coordI(x, y, startx, starty,
 				&drx, &dry);
 			dest_rect.x = drx;
 			dest_rect.y = dry;
 			SDL_RenderTexture(state->renderer, state->sprites,
 				&cell_rect, &dest_rect);
 		}
 }
 
 void
 reset(struct State* state)
 {
 	int x, y;
 	assert(state != NULL);
 
 	if (!state->search_shortest)
 		state->location_pointer = 0;
 
 	for (y = 0; y < state->grid_height; y++)
 		for (x = 0; x < state->grid_width; x++)
 			if (state->grid[INDEX(x, y)].contents == CELL_FAIL
 				|| state->grid[INDEX(x, y)].contents == CELL_OK)
 				state->grid[INDEX(x, y)].contents = CELL_EMPTY;
 	state->hero.x = state->start.x;
 	state->hero.y = state->start.y;
 	state->state  = STATE_SEARCHING_PAUSED;
 	state->redraw = 1;
 }
 
 void
 reset_path(struct State* state)
 {
 	struct Cell* c	  = NULL;
 	struct Cell* grid = NULL;
 	int x, y;
 
 	assert(state != NULL);
 
 	grid = state->grid;
 	for (y = 0; y < LABYRINTH_MAXHEIGHT; y++)
 		for (x = 0; x < LABYRINTH_MAXWIDTH; 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
 step_animation(struct State* state)
 {
 	struct Cell* from = NULL;
 	struct Cell* to	  = NULL;
 	int isx, isy, iex, iey;
 
 	assert((state != NULL)
 		&& !(state->animation.delta.x == 0.0f
 			&& state->animation.delta.y == 0.0f));
 
 	if (state->state == STATE_SEARCHING_PAUSED)
 		return;
 
 	if (!state->search_shortest)
 		goto step_animation_brute_force;
 
 	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 (!from->starting)
 			from->contents = CELL_OK;
 
 		if (to->ending)
 		{
 			state->animation.active = 0;
 			print_debug("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;
 
 			print_debug("Next node on path: (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 			print_debug(
 				"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
 		{
 			print_debug("End of path at (%0.0f, %0.0f)",
 				state->animation.end.x, state->animation.end.y);
 			state->animation.active = 0;
 		}
 
 		print_debug("grid[%d][%d] = %d <-> grid[%d][%d] = %d", iey, iex,
 			to->contents, isy, isx, from->contents);
 		state->hero.x = to->coords.x;
 		state->hero.y = to->coords.y;
 
 		if (to->ending)
 		{
 			state->state  = STATE_SUCCESS;
 			state->redraw = 1;
 		}
 	}
 
 step_animation_brute_force:
 	print_debug("step_animation: (%0.2f, %0.2f) => (%0.2f, %0.2f)",
 		state->animation.position.x, state->animation.position.y,
 		state->animation.position.x + state->animation.delta.x,
 		state->animation.position.y + state->animation.delta.y);
 	state->animation.position.x += state->animation.delta.x;
 	state->animation.position.y += state->animation.delta.y;
 	state->animation.step++;
 
 	if (state->search_shortest)
 		return;
 
 	if (state->animation.step == state->animation.final_step)
 	{
 		state->animation.active = 0;
 		state->hero.x		= (int)state->animation.end.x;
 		state->hero.y		= (int)state->animation.end.y;
 	}
 }
 
 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++;
 	}
 	print_debug("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)
 	{
 		print_error("try_load: IMG_LoadTexture failed: %s",
 			SDL_GetError());
 		snprintf(tex_pathname, BUFSIZE, "./%s", filename);
 		print_debug("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);
 		}
 		print_debug("try_load: success (%s)", tex_pathname);
 	}
 
 	return tex;
 }
 
 int
 main(int argc, char** argv)
 {
 	SDL_Event event;
 	struct State state;
 	float px, py;
 	unsigned int last_time, current_time;
 	char datafile_pathname[BUFSIZE];
 	int optind = 1;
 
 	init_state(&state);
 
 	if (!SDL_Init(SDL_INIT_VIDEO))
 	{
 		print_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))
 	{
 		print_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);
 
 	if (load_textures(&state) < 0)
 		do_exit(1, &state);
 
 	if (argc > 1)
 	{
 		if (!strcmp(argv[1], "-s"))
 		{
 			state.search_shortest = 1;
 			optind++;
 			if (optind >= argc)
 				goto load_default_file;
 		}
 
 		if (load_labyrinth(&state, argv[optind]) < 0)
 		{
 			print_error("load_labyrinth failed: %s (%s)",
 				strerror(errno), argv[optind]);
 			do_exit(1, &state);
 		}
 	}
 	else
 	{
 	load_default_file:
 		snprintf(datafile_pathname, BUFSIZE, "%s/%s", DATADIR,
 			DEFAULT_DATAFILE);
 		if (load_labyrinth(&state, datafile_pathname) < 0)
 		{
 			print_debug("fopen failed: %s (%s)", strerror(errno),
 				datafile_pathname);
 			snprintf(datafile_pathname, BUFSIZE, "./%s",
 				DEFAULT_DATAFILE);
 			print_debug("trying %s", datafile_pathname);
 			if (load_labyrinth(&state, datafile_pathname) < 0)
 			{
 				print_error("fopen failed: %s (%s)",
 					strerror(errno), datafile_pathname);
 				do_exit(1, &state);
 			}
 		}
 	}
 	state.location_stack   = calloc(LOCATION_STACK_MAX, sizeof(SDL_Point));
 	state.animation.active = 0;
 
 	SDL_HideCursor();
 	SDL_GetMouseState(&px, &py);
 	state.pointer.x = px;
 	state.pointer.y = py;
 	last_time	= SDL_GetTicks();
 	while (state.running)
 	{
 		current_time = SDL_GetTicks();
 		if (state.animation.active)
 		{
 			if (current_time > last_time + 1000 / 60)
 			{
 				draw(&state);
 				step_animation(&state);
 				last_time = current_time;
 			}
 		}
 		else
 		{
 			if (state.state == STATE_SEARCHING)
 			{
 				next_step(&state);
 			}
 
 			if (state.redraw)
 			{
 				draw(&state);
 				state.redraw = 0;
 			}
 		}
 
 		while (SDL_PollEvent(&event))
 			handle_event(&state, &event);
 	}
 
 	return 0;
 }