path: root/src/main.c

/*
 * Copyright (c) 2019-2020, yzrh <yzrh@noema.org>
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>

#ifdef __linux__

#include <sys/types.h>
#include <sys/stat.h>
#include <poll.h>

#endif /* __linux__ */

#include <SDL2/SDL.h>
#include <SDL2/SDL_ttf.h>

#ifdef SOUND

#include <SDL2/SDL_mixer.h>

#endif /* SOUND */

#include "version.h"
#include "extern.h"
#include "screen.h"

#ifdef GPIO

#include "gpio.h"

#endif /* GPIO */

static pthread_mutex_t mutex;
static pthread_cond_t cond;

static SDL_Renderer *renderer;
static TTF_Font *font_20;
static TTF_Font *font_24;

/*
 * Default to keyboard,
 * GPIO inputs are mapped to controller keys
 */
static Snake_Device device = SNAKE_KEYBOARD;
static int selection = 0;

static Snake_Text text_title;
static Snake_Text text_help_top;
static Snake_Text text_help_0;
static Snake_Text text_help_1;
static Snake_Text text_help_2;
static Snake_Text text_help_3;
static Snake_Text text_help_4;
static Snake_Text text_help_5;
static Snake_Text text_help_6;
static Snake_Text text_help_7;

static Snake_Text text_score;

static Snake_Text text_prompt_start;
static Snake_Text text_prompt_resume;

static Snake_Text text_prompt_0;
static Snake_Text text_prompt_1;
static Snake_Text text_prompt_2;

static bool start = 1;
static bool end = 0;
static bool begin = 0;

static bool god = 0;
static bool reset = 0;
static bool wait = 0;
static bool multiplayer = 0;
static bool flappy = 0;

static struct timespec delay = {
	.tv_sec = 0,
	.tv_nsec = TICK_TIME_INIT
};

static int score;
static int result;
static int distance;
static int speed;

static Snake_Input input = SNAKE_EMPTY;
static Snake_Input head[2][2];

static Snake_Pos *snake0 = NULL;
static Snake_Pos *snake1 = NULL;

static int fruit[2];

static Snake_Pos *gap = NULL;

static void*
handler_rendering(void *args)
{
	const SDL_Color fg = {
		COLOUR_FOREGROUND_R,
		COLOUR_FOREGROUND_G,
		COLOUR_FOREGROUND_B
	};
	const SDL_Color bg = {
		COLOUR_BACKGROUND_R,
		COLOUR_BACKGROUND_G,
		COLOUR_BACKGROUND_B
	};
	const SDL_Color bg_s = {
		COLOUR_BACKGROUND_SHADE_R,
		COLOUR_BACKGROUND_SHADE_G,
		COLOUR_BACKGROUND_SHADE_B
	};

	char result_str[23];
	char score_str[11];

	Snake_Text text_result;

	Snake_Text text_welcome;
	Snake_Text text_clear;
	Snake_Text text_gameover;
	Snake_Text text_pause;

	while (!end) {
		draw_clear(renderer);
		draw_colour(renderer, SNAKE_FOREGROUND);

		draw_wall(renderer);

		draw_text(renderer,
			font_20,
			SCREEN_HEIGHT + 4 * SCREEN_UNIT_X,
			SCREEN_UNIT_Y,
			"Snake",
			1,
			0,
			fg,
			bg,
			&text_title);
		draw_text(renderer,
			font_20,
			SCREEN_HEIGHT + 4 * SCREEN_UNIT_X,
			2 * SCREEN_UNIT_Y,
			"Help",
			1,
			0,
			fg,
			bg,
			&text_help_top);
		if (god)
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				2.5 * SCREEN_UNIT_Y,
				"0. Don't forget to cheat",
				0,
				0,
				fg,
				bg,
				&text_help_0);
		if (device == SNAKE_KEYBOARD) {
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				3 * SCREEN_UNIT_Y,
				"1. Classic: use arrow keys to move",
				0,
				0,
				fg,
				bg,
				&text_help_1);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				3.5 * SCREEN_UNIT_Y,
				"2. Multiplayer: use s, e, d, f keys",
				0,
				0,
				fg,
				bg,
				&text_help_2);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				4 * SCREEN_UNIT_Y,
				"3. Flappy: SPACE key to jump",
				0,
				0,
				fg,
				bg,
				&text_help_3);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				4.5 * SCREEN_UNIT_Y,
				"4. ESCAPE key to pause",
				0,
				0,
				fg,
				bg,
				&text_help_4);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				5 * SCREEN_UNIT_Y,
				"5. r key to reset",
				0,
				0,
				fg,
				bg,
				&text_help_5);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				5.5 * SCREEN_UNIT_Y,
				"6. m key to toggle music",
				0,
				0,
				fg,
				bg,
				&text_help_6);
		} else if (device == SNAKE_TOUCHSCREEN) {
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				3 * SCREEN_UNIT_Y,
				"1. Classic: swipe to move",
				0,
				0,
				fg,
				bg,
				&text_help_1);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				3.5 * SCREEN_UNIT_Y,
				"2. Multiplayer: use different side",
				0,
				0,
				fg,
				bg,
				&text_help_2);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				4 * SCREEN_UNIT_Y,
				"3. Flappy: tap to jump",
				0,
				0,
				fg,
				bg,
				&text_help_3);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				4.5 * SCREEN_UNIT_Y,
				"4. Tap here to pause",
				0,
				1,
				fg,
				bg,
				&text_help_4);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				5 * SCREEN_UNIT_Y,
				"5. Tap here to reset",
				0,
				1,
				fg,
				bg,
				&text_help_5);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				5.5 * SCREEN_UNIT_Y,
				"6. Tap here to toggle music",
				0,
				1,
				fg,
				bg,
				&text_help_6);
		} else if (device == SNAKE_CONTROLLER) {
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				3 * SCREEN_UNIT_Y,
				"1. Classic: use D-pad to move",
				0,
				0,
				fg,
				bg,
				&text_help_1);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				3.5 * SCREEN_UNIT_Y,
				"2. Multiplayer: second controller",
				0,
				0,
				fg,
				bg,
				&text_help_2);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				4 * SCREEN_UNIT_Y,
				"3. Flappy: Press A to jump",
				0,
				0,
				fg,
				bg,
				&text_help_3);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				4.5 * SCREEN_UNIT_Y,
				"4. Press BACK to pause",
				0,
				0,
				fg,
				bg,
				&text_help_4);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				5 * SCREEN_UNIT_Y,
				"5. Press X to reset",
				0,
				0,
				fg,
				bg,
				&text_help_5);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
				5.5 * SCREEN_UNIT_Y,
				"6. Press Y to toggle music",
				0,
				0,
				fg,
				bg,
				&text_help_6);
		}
		draw_text(renderer,
			font_20,
			SCREEN_HEIGHT + SCREEN_UNIT_X / 4,
			6 * SCREEN_UNIT_Y,
			"7. Have fun",
			0,
			0,
			fg,
			bg,
			&text_help_7);

		snprintf(score_str, 11, "Score: %d", score);

		draw_text(renderer,
			font_20,
			SCREEN_HEIGHT + 4 * SCREEN_UNIT_X,
			7 * SCREEN_UNIT_Y,
			score_str,
			1,
			0,
			fg,
			bg,
			&text_score);

		draw_snake(renderer, &snake0);

		if (flappy) {
			draw_pipe(renderer, &gap);
		} else if (multiplayer)
			draw_snake(renderer, &snake1);
		else if (!start)
			draw_fruit(renderer, fruit);

		if (start || reset) {
			if (multiplayer) {
				if (result == 3)
					snprintf(result_str, 23, "Draw");
				else if (result > 0)
					snprintf(result_str, 23,
						"%s is the winner",
						result == 1 ?
						"Player 2" : "Player 1");
				else
					snprintf(result_str, 23, "Reset");
				text_result.cache = 0;

				draw_text(renderer,
					font_24,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 -
					0.75 * SCREEN_UNIT_Y,
					result_str,
					1,
					0,
					fg,
					bg_s,
					&text_result);
			}
			if (start)
				draw_text(renderer,
					font_24,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2,
					"Welcome",
					1,
					0,
					fg,
					bg_s,
					&text_welcome);
			else if (!flappy && !multiplayer &&
				score == SCREEN_BLOCK / 2)
				draw_text(renderer,
					font_24,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2,
					"Why don't you have legs?",
					1,
					0,
					fg,
					bg_s,
					&text_clear);
			else
				draw_text(renderer,
					font_24,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2,
					"Game over!",
					1,
					0,
					fg,
					bg_s,
					&text_gameover);
			if (device == SNAKE_KEYBOARD)
				draw_text(renderer,
					font_20,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 +
					0.75 * SCREEN_UNIT_Y,
					"Press RETURN key for selection",
					1,
					0,
					fg,
					bg_s,
					&text_prompt_start);
			else if (device == SNAKE_TOUCHSCREEN)
				draw_text(renderer,
					font_20,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 +
					0.75 * SCREEN_UNIT_Y,
					"Tap the option to select",
					1,
					0,
					fg,
					bg_s,
					&text_prompt_start);
			else if (device == SNAKE_CONTROLLER)
				draw_text(renderer,
					font_20,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 +
					0.75 * SCREEN_UNIT_Y,
					"Press START to select",
					1,
					0,
					fg,
					bg_s,
					&text_prompt_start);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT / 2,
				SCREEN_HEIGHT / 2 + 1.5 * SCREEN_UNIT_Y,
				"Classic",
				1,
				device == SNAKE_TOUCHSCREEN ||
				selection == 0 ? 1 : 0,
				fg,
				bg_s,
				&text_prompt_0);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT / 2,
				SCREEN_HEIGHT / 2 + 2.25 * SCREEN_UNIT_Y,
				"Multiplayer",
				1,
				device == SNAKE_TOUCHSCREEN ||
				selection == 1 ? 1 : 0,
				fg,
				bg_s,
				&text_prompt_1);
			draw_text(renderer,
				font_20,
				SCREEN_HEIGHT / 2,
				SCREEN_HEIGHT / 2 + 3 * SCREEN_UNIT_Y,
				"Flappy",
				1,
				device == SNAKE_TOUCHSCREEN ||
				selection == 2 ? 1 : 0,
				fg,
				bg_s,
				&text_prompt_2);
		} else if (wait) {
			draw_text(renderer,
				font_24,
				SCREEN_HEIGHT / 2,
				SCREEN_HEIGHT / 2,
				"Paused",
				1,
				0,
				fg,
				bg_s,
				&text_pause);
			if (device == SNAKE_KEYBOARD)
				draw_text(renderer,
					font_20,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 +
					0.75 * SCREEN_UNIT_Y,
					"Press ESCAPE key to resume",
					1,
					0,
					fg,
					bg_s,
					&text_prompt_resume);
			else if (device == SNAKE_TOUCHSCREEN)
				draw_text(renderer,
					font_20,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 +
					0.75 * SCREEN_UNIT_Y,
					"Tap here to resume",
					1,
					1,
					fg,
					bg_s,
					&text_prompt_resume);
			else if (device == SNAKE_CONTROLLER)
				draw_text(renderer,
					font_20,
					SCREEN_HEIGHT / 2,
					SCREEN_HEIGHT / 2 +
					0.75 * SCREEN_UNIT_Y,
					"Press START to resume",
					1,
					0,
					fg,
					bg_s,
					&text_prompt_resume);
		}

		SDL_RenderPresent(renderer);
	}
	return 0;
}

static void*
handler_logic(void *args)
{
	struct timespec clock_start;
	struct timespec clock_end;
	double clock_pass = 0;
	int pipe_dim[6];
	int pipe_pos = 0;

	clock_gettime(CLOCK_MONOTONIC, &clock_start);

	for (;;) {
		pthread_mutex_lock(&mutex);
		while (start || reset || wait) {
			if (!wait) {
				clock_pass = 0;
				pipe_pos = 0;
			}
			pthread_cond_wait(&cond, &mutex);
			clock_gettime(CLOCK_MONOTONIC, &clock_start);
		}
		pthread_mutex_unlock(&mutex);

		if (end)
			return 0;

		if (flappy) {
			pthread_mutex_lock(&mutex);
			while (!begin)
				pthread_cond_wait(&cond, &mutex);
			pthread_mutex_unlock(&mutex);

			game_pipe_bound(&gap, pipe_dim);

			if (pipe_pos - SCREEN_UNIT > pipe_dim[0]) {
				score++;
				text_score.cache = 0;
			}
			pipe_pos = pipe_dim[0];

			if (!god && (collision(
				(int[]) {snake0->next->x, snake0->next->y,
				2 * SCREEN_UNIT, SCREEN_UNIT},
				(int[]) {pipe_dim[0], pipe_dim[2],
				pipe_dim[1], pipe_dim[3]}) ||
				collision(
				(int[]) {snake0->next->x, snake0->next->y,
				2 * SCREEN_UNIT, SCREEN_UNIT},
				(int[]) {pipe_dim[0], pipe_dim[4],
				pipe_dim[1], pipe_dim[5]}) ||
				snake0->y < 0 ||
				snake0->y + SCREEN_UNIT > SCREEN_HEIGHT)) {
				pthread_mutex_lock(&mutex);
				reset = 1;
				pthread_mutex_unlock(&mutex);
			} else {
				game_pipe_move(&gap);

				game_pipe_pos(&gap, &result);
				if (result == 3) {
					game_pipe_del(&gap);
					game_pipe_add(&gap);
				} else if (result == 2) {
					game_pipe_add(&gap);
				} else if (result == 1) {
					game_pipe_del(&gap);
				}
			}
		} else if (!multiplayer) {
			game_snake_move(&snake0, NULL,
				head[0], !god, &result);

			if (result == 0 || god) {
				head[1][0] = head[0][0];

				if (collision_block(fruit,
					(int[]) {snake0->x, snake0->y})) {
					score++;
					text_score.cache = 0;
					game_snake_grow(&snake0);

					if (score == SCREEN_BLOCK / 2) {
						pthread_mutex_lock(&mutex);
						reset = 1;
						pthread_mutex_unlock(&mutex);
					}

					game_fruit(fruit, &snake0);

					if (delay.tv_nsec - TICK_TIME_DEC >=
						TICK_TIME_MIN)
						delay.tv_nsec -= TICK_TIME_DEC;
				}
			} else {
				pthread_mutex_lock(&mutex);
				reset = 1;
				pthread_mutex_unlock(&mutex);
			}
		} else {
			game_snake_move(&snake0, &snake1,
				head[0], !god, &result);

			if (result == 0 || god) {
				head[1][0] = head[0][0];
				head[1][1] = head[0][1];

				clock_gettime(CLOCK_MONOTONIC, &clock_end);
				clock_pass += (clock_end.tv_sec -
					clock_start.tv_sec) +
					(clock_end.tv_nsec -
					clock_start.tv_nsec) * 0.000000001;
				clock_gettime(CLOCK_MONOTONIC, &clock_start);

				score = clock_pass;
				text_score.cache = 0;
				game_snake_grow(&snake0);
				game_snake_grow(&snake1);
			} else {
				pthread_mutex_lock(&mutex);
				reset = 1;
				pthread_mutex_unlock(&mutex);
			}
		}

		nanosleep(&delay, NULL);
	}
}

static void*
handler_gravity(void *args)
{
	const struct timespec delay = {
		.tv_sec = 0,
		.tv_nsec = 1000000000 / SCREEN_UNIT
	};

	for (;;) {
		pthread_mutex_lock(&mutex);
		while (!flappy || !begin || start || reset || wait)
			pthread_cond_wait(&cond, &mutex);
		pthread_mutex_unlock(&mutex);

		if (end)
			return 0;

		if (distance > 0) {
			game_snake_fall(&snake0, 0,
				distance > speed ? speed : distance);
			speed++;

			pthread_mutex_lock(&mutex);
			distance -= distance > speed ? speed : distance;
			if (distance == 0)
				speed = 1;
			pthread_mutex_unlock(&mutex);
		} else {
			game_snake_fall(&snake0, 1, speed);
			speed++;
		}

		nanosleep(&delay, NULL);
	}
}

#ifdef GPIO

#ifdef __FreeBSD__

static void*
handler_gpio(void *args)
{
	const struct timespec delay = {
		.tv_sec = 0,
		.tv_nsec = 50000000
	};

	SDL_Event event;
	event.type = SDL_CONTROLLERBUTTONUP;

	while (!end) {
		if (gpio_read(GPIO_PIN_IN0) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_LEFT;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN1) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_UP;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN2) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_DOWN;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN3) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_RIGHT;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN4) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_BACK;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN5) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_GUIDE;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN6) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_START;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN7) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_A;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN8) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_B;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN9) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_X;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN10) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_Y;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN11) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN12) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN13) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_LEFTSTICK;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN14) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_RIGHTSTICK;
			event.cbutton.which = 0;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN15) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_LEFT;
			event.cbutton.which = 1;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN16) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_UP;
			event.cbutton.which = 1;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN17) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_DOWN;
			event.cbutton.which = 1;
			SDL_PushEvent(&event);
		} else if (gpio_read(GPIO_PIN_IN18) == 0) {
			event.cbutton.button =
				SDL_CONTROLLER_BUTTON_DPAD_RIGHT;
			event.cbutton.which = 1;
			SDL_PushEvent(&event);
		}

		nanosleep(&delay, NULL);
	}
	return 0;
}

#elif __linux__

static void*
handler_gpio(void *args)
{
	struct pollfd pfd[19];
	char path[29];

	for (int i = 0; i < 19; i++)
		pfd[i].events = POLLPRI | POLLERR;

	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN0);
	pfd[0].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN1);
	pfd[1].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN2);
	pfd[2].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN3);
	pfd[3].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN4);
	pfd[4].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN5);
	pfd[5].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN6);
	pfd[6].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN7);
	pfd[7].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN8);
	pfd[8].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN9);
	pfd[9].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN10);
	pfd[10].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN11);
	pfd[11].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN12);
	pfd[12].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN13);
	pfd[13].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN14);
	pfd[14].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN15);
	pfd[15].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN16);
	pfd[16].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN17);
	pfd[17].fd = open(path, O_RDONLY);
	snprintf(path, 29, "/sys/class/gpio/gpio%d/value", GPIO_PIN_IN18);
	pfd[18].fd = open(path, O_RDONLY);

	SDL_Event event;
	event.type = SDL_CONTROLLERBUTTONUP;

	char val[2];

	while (!end) {
		poll(pfd, 19, -1);

		for (int i = 0; i < 19; i++) {
			if (pfd[i].revents & (POLLPRI | POLLERR)) {
				pfd[i].revents &= ~(POLLPRI | POLLERR);
				read(pfd[i].fd, val, 2);
				lseek(pfd[i].fd, 0, SEEK_SET);

				if (atoi(val) != 0)
					continue;

				input_gpio(i % 15, &event.cbutton.button);

				if (i < 15)
					event.cbutton.which = 0;
				else
					event.cbutton.which = 1;

				SDL_PushEvent(&event);
				break;
			}
		}
	}
	return 0;
}

#endif /* __FreeBSD__ */

#endif /* GPIO */

int
main(void)
{
	printf("Snake " VERSION "." RELEASE "." PATCH EXTRA "\n"
		"Copyright (c) 2019-2020, yzrh <yzrh@noema.org>\n");

	if (SDL_Init(SDL_INIT_VIDEO |
		SDL_INIT_AUDIO |
		SDL_INIT_GAMECONTROLLER) != 0) {
		fprintf(stderr, "SDL initialisation failure: %s\n",
			SDL_GetError());
		return 1;
	}

	SDL_Window *window = SDL_CreateWindow(
		"Snake " VERSION "." RELEASE "." PATCH EXTRA,
		SDL_WINDOWPOS_UNDEFINED,
		SDL_WINDOWPOS_UNDEFINED,
		SCREEN_WIDTH,
		SCREEN_HEIGHT,
		SDL_WINDOW_OPENGL);

	if (window == NULL) {
		fprintf(stderr, "Window creation failure: %s\n",
			SDL_GetError());
		return 1;
	}

	renderer = SDL_CreateRenderer(
		window,
		-1,
		SDL_RENDERER_ACCELERATED |
		SDL_RENDERER_PRESENTVSYNC);

	if (renderer == NULL) {
		fprintf(stderr, "Renderer creation failure: %s\n",
			SDL_GetError());
		return 1;
	}

	if (TTF_Init() != 0) {
		fprintf(stderr, "TTF initialisation failure: %s\n",
			TTF_GetError());
		return 1;
	}

	font_20 = TTF_OpenFont("../contrib/font.ttf", 20);
	font_24 = TTF_OpenFont("../contrib/font.ttf", 24);

	if (font_20 == NULL) {
		font_20 = TTF_OpenFont("/usr/local/share/snake/font.ttf", 20);
		font_24 = TTF_OpenFont("/usr/local/share/snake/font.ttf", 24);
	}

	if (font_20 == NULL) {
		font_20 = TTF_OpenFont("/usr/share/snake/font.ttf", 20);
		font_24 = TTF_OpenFont("/usr/share/snake/font.ttf", 24);
	}

	if (font_20 == NULL) {
		fprintf(stderr, "%s\n", TTF_GetError());
		return 1;
	}

#ifdef SOUND

	if ((Mix_Init(MIX_INIT_FLAC) & MIX_INIT_FLAC) != MIX_INIT_FLAC)
		fprintf(stderr, "Mixer initialisation failure: %s\n",
			Mix_GetError());

	if (Mix_OpenAudio(48000, AUDIO_S16SYS, 2, 4096) == -1)
		fprintf(stderr, "%s\n", Mix_GetError());

	Mix_Music *music = Mix_LoadMUS("../contrib/music.flac");

	if (music == NULL)
		music = Mix_LoadMUS("/usr/local/share/snake/music.flac");

	if (music == NULL)
		music = Mix_LoadMUS("/usr/share/snake/music.flac");

	if (music == NULL)
		fprintf(stderr, "%s\n", Mix_GetError());

	if (Mix_PlayMusic(music, -1) == -1)
		fprintf(stderr, "Audio playback failure: %s\n",
			Mix_GetError());

#endif /* SOUND */

#ifdef GPIO

#ifdef __linux__

	gpio_export(GPIO_PIN_IN0);
	gpio_export(GPIO_PIN_IN1);
	gpio_export(GPIO_PIN_IN2);
	gpio_export(GPIO_PIN_IN3);
	gpio_export(GPIO_PIN_IN4);
	gpio_export(GPIO_PIN_IN5);
	gpio_export(GPIO_PIN_IN6);
	gpio_export(GPIO_PIN_IN7);
	gpio_export(GPIO_PIN_IN8);
	gpio_export(GPIO_PIN_IN9);
	gpio_export(GPIO_PIN_IN10);
	gpio_export(GPIO_PIN_IN11);
	gpio_export(GPIO_PIN_IN12);
	gpio_export(GPIO_PIN_IN13);
	gpio_export(GPIO_PIN_IN14);
	gpio_export(GPIO_PIN_IN15);
	gpio_export(GPIO_PIN_IN16);
	gpio_export(GPIO_PIN_IN17);
	gpio_export(GPIO_PIN_IN18);

	/* Wait for sysfs directory to show up */
	sleep(1);

#endif /* __linux__ */

	gpio_config(GPIO_PIN_IN0, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN1, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN2, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN3, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN4, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN5, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN6, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN7, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN8, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN9, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN10, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN11, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN12, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN13, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN14, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN15, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN16, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN17, GPIO_IN, GPIO_INT);
	gpio_config(GPIO_PIN_IN18, GPIO_IN, GPIO_INT);

#endif /* GPIO */

	int seed;
	int random = open("/dev/random", O_RDONLY);
	if (read(random, &seed, sizeof(int)) > 0)
		srand(seed);
	close(random);

	SDL_JoystickID player = 0;
	SDL_Event event;

	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);
	pthread_t th_renderer;
	pthread_t th_logic;
	pthread_t th_gravity;

	#ifdef GPIO

	pthread_t th_gpio;

	#endif /* GPIO */

	pthread_create(&th_renderer, NULL, handler_rendering, NULL);
	pthread_create(&th_logic, NULL, handler_logic, NULL);
	pthread_create(&th_gravity, NULL, handler_gravity, NULL);

	#ifdef GPIO

	pthread_create(&th_gpio, NULL, handler_gpio, NULL);

	#endif /* GPIO */

	while (SDL_WaitEvent(&event)) {
		if (event.type == SDL_QUIT)
			break;

		switch (event.type) {
			case SDL_KEYUP:
				if (device != SNAKE_KEYBOARD) {
					device = SNAKE_KEYBOARD;
					text_help_1.cache = 0;
					text_help_2.cache = 0;
					text_help_3.cache = 0;
					text_help_4.cache = 0;
					text_help_5.cache = 0;
					text_help_6.cache = 0;
					text_prompt_start.cache = 0;
					text_prompt_resume.cache = 0;
				}
				input_keyboard(event.key.keysym.sym, &input);
				if (multiplayer &&
					(event.key.keysym.sym ==
					SDLK_s ||
					event.key.keysym.sym ==
					SDLK_e ||
					event.key.keysym.sym ==
					SDLK_d ||
					event.key.keysym.sym ==
					SDLK_f))
					player = 1;
				else
					player = 0;
				break;
			case SDL_FINGERUP:
				if (device != SNAKE_TOUCHSCREEN) {
					device = SNAKE_TOUCHSCREEN;
					text_help_1.cache = 0;
					text_help_2.cache = 0;
					text_help_3.cache = 0;
					text_help_4.cache = 0;
					text_help_5.cache = 0;
					text_help_6.cache = 0;
					text_prompt_start.cache = 0;
					text_prompt_resume.cache = 0;
				}
				if (start || reset || wait) {
					if (collision_bound(
						event.tfinger.x,
						event.tfinger.y,
						&text_help_5)) {
						input = SNAKE_RESET;
					} else if (collision_bound(
						event.tfinger.x,
						event.tfinger.y,
						&text_help_6)) {
						input = SNAKE_MUSIC;
					} else if (wait) {
						if (collision_bound(
							event.tfinger.x,
							event.tfinger.y,
							&text_prompt_resume))
							input = SNAKE_PAUSE;
					} else {
						if (collision_bound(
							event.tfinger.x,
							event.tfinger.y,
							&text_prompt_0)) {
							selection = 0;
							input = SNAKE_SELECT;
						} else if (collision_bound(
							event.tfinger.x,
							event.tfinger.y,
							&text_prompt_1)) {
							selection = 1;
							input = SNAKE_SELECT;
						} else if (collision_bound(
							event.tfinger.x,
							event.tfinger.y,
							&text_prompt_2)) {
							selection = 2;
							input = SNAKE_SELECT;
						}
					}
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_help_4)) {
					input = SNAKE_PAUSE;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_help_5)) {
					input = SNAKE_RESET;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_help_6)) {
					input = SNAKE_MUSIC;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_help_top)) {
					input = SNAKE_GOD;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_score)) {
					input = SNAKE_GROW;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_title)) {
					input = SNAKE_TELEPORT;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_help_1)) {
					input = SNAKE_TICK_DECREASE;
				} else if (collision_bound(
					event.tfinger.x,
					event.tfinger.y,
					&text_help_7)) {
					input = SNAKE_TICK_INCREASE;
				} else if (flappy) {
					input = SNAKE_JUMP;
				} else {
					input = SNAKE_EMPTY;
				}
				break;
			case SDL_FINGERMOTION:
				if (device != SNAKE_TOUCHSCREEN) {
					device = SNAKE_TOUCHSCREEN;
					text_help_1.cache = 0;
					text_help_2.cache = 0;
					text_help_3.cache = 0;
					text_help_4.cache = 0;
					text_help_5.cache = 0;
					text_help_6.cache = 0;
					text_prompt_start.cache = 0;
					text_prompt_resume.cache = 0;
				}
				if ((event.tfinger.dx *
					event.tfinger.dx) >
					(event.tfinger.dy *
					event.tfinger.dy)) {
					if (event.tfinger.dx > 1)
						input = SNAKE_RIGHT;
					else if (event.tfinger.dx < -1)
						input = SNAKE_LEFT;
				} else {
					if (event.tfinger.dy > 1)
						input = SNAKE_DOWN;
					else if (event.tfinger.dy < -1)
						input = SNAKE_UP;
				}
				if (multiplayer &&
					event.tfinger.x > SCREEN_HEIGHT / 2)
					player = 1;
				else
					player = 0;
				break;
			case SDL_CONTROLLERBUTTONUP:
				if (device != SNAKE_CONTROLLER) {
					device = SNAKE_CONTROLLER;
					text_help_1.cache = 0;
					text_help_2.cache = 0;
					text_help_3.cache = 0;
					text_help_4.cache = 0;
					text_help_5.cache = 0;
					text_help_6.cache = 0;
					text_prompt_start.cache = 0;
					text_prompt_resume.cache = 0;
				}
				input_controller(event.cbutton.button, &input);
				player = event.cbutton.which;
				break;
			default:
				break;
		}

		if (!start && !reset && !wait) {
			switch (input) {
				case SNAKE_LEFT:
					if (head[1][player] != SNAKE_RIGHT)
						head[0][player] = SNAKE_LEFT;
					break;
				case SNAKE_UP:
					if (head[1][player] != SNAKE_DOWN)
						head[0][player] = SNAKE_UP;
					break;
				case SNAKE_DOWN:
					if (head[1][player] != SNAKE_UP)
						head[0][player] = SNAKE_DOWN;
					break;
				case SNAKE_RIGHT:
					if (head[1][player] != SNAKE_LEFT)
						head[0][player] = SNAKE_RIGHT;
					break;
				case SNAKE_JUMP:
					if (!begin) {
						pthread_mutex_lock(&mutex);
						begin = 1;
						pthread_cond_broadcast(&cond);
						pthread_mutex_unlock(&mutex);
					}
					if (flappy) {
						pthread_mutex_lock(&mutex);
						distance += PIPE_GAP / 2 *
							SCREEN_UNIT;
						if (distance == 0)
							speed = 1;
						pthread_mutex_unlock(&mutex);
					}
					break;
				case SNAKE_RESET:
					pthread_mutex_lock(&mutex);
					reset = 1;
					pthread_mutex_unlock(&mutex);
					break;
				case SNAKE_GOD:
					god = 1;
					break;
				case SNAKE_GROW:
					if (god && !flappy && !multiplayer)
						game_snake_grow(&snake0);
					break;
				case SNAKE_TELEPORT:
					if (god) {
						snake0->x = snake0->y =
							SCREEN_HEIGHT / 2;
						if (flappy) {
							snake0->next->x =
								SCREEN_HEIGHT /
								2 - SCREEN_UNIT;
							snake0->next->y =
								SCREEN_HEIGHT /
								2;
						}
					}
					break;
				case SNAKE_MUSIC:
#ifdef SOUND
					if (Mix_PausedMusic())
						Mix_ResumeMusic();
					else
						Mix_PauseMusic();
#endif /* SOUND */
					break;
				case SNAKE_TICK_DECREASE:
					if (god && !flappy && delay.tv_nsec -
						TICK_TIME_DEC >= TICK_TIME_MIN)
						delay.tv_nsec -= TICK_TIME_DEC;
					break;
				case SNAKE_TICK_INCREASE:
					if (god && !flappy)
						delay.tv_nsec += TICK_TIME_DEC;
					break;
				case SNAKE_PAUSE:
					wait = 1;
					break;
				default:
					break;
			}
		} else {
			switch (input) {
				case SNAKE_RESET:
					wait = 0;

					pthread_mutex_lock(&mutex);
					reset = 1;
					pthread_mutex_unlock(&mutex);
					break;
				case SNAKE_MUSIC:
#ifdef SOUND
					if (Mix_PausedMusic())
						Mix_ResumeMusic();
					else
						Mix_PauseMusic();
#endif /* SOUND */
					break;
				case SNAKE_SELECT:
					if (wait)
						break;

					if (selection == 0) {
						flappy = 0;
						multiplayer = 0;
					} else if (selection == 1) {
						flappy = 0;
						multiplayer = 1;
					} else if (selection == 2) {
						multiplayer = 0;
						flappy = 1;
					}

					delay.tv_nsec = TICK_TIME_INIT;

					god = 0;

					head[0][0] = head[0][1] =
						SNAKE_UP;
					head[1][0] = head[1][1] =
						SNAKE_EMPTY;

					score = 0;
					text_score.cache = 0;

					if (flappy) {
						delay.tv_nsec = TICK_TIME_INIT /
							SCREEN_UNIT;

						game_snake_init(&snake0, 0);

						snake0->next->x =
							SCREEN_HEIGHT / 2 -
							SCREEN_UNIT;
						snake0->next->y =
							SCREEN_HEIGHT / 2;

						game_pipe_init(&gap);

						pthread_mutex_lock(&mutex);
						begin = 0;
						distance = 0;
						speed = 1;
						pthread_mutex_unlock(&mutex);
					} else if (!multiplayer) {
						game_snake_init(
							&snake0, 0);
						game_fruit(
							fruit,
							&snake0);
					} else {
						game_snake_init(
							&snake0,
							-4 *
							SCREEN_UNIT);
						game_snake_init(
							&snake1,
							4 *
							SCREEN_UNIT);
					}
					start = 0;

					pthread_mutex_lock(&mutex);
					reset = 0;
					pthread_cond_broadcast(&cond);
					pthread_mutex_unlock(&mutex);
					break;
				case SNAKE_PAUSE:
					wait = 0;

					pthread_mutex_lock(&mutex);
					pthread_cond_broadcast(&cond);
					pthread_mutex_unlock(&mutex);
					break;
				case SNAKE_UP:
					if ((start || reset) &&
						selection - 1 >= 0)
						selection--;
					break;
				case SNAKE_DOWN:
					if ((start || reset) &&
						selection + 1 <= 2)
						selection++;
					break;
				default:
					break;
			}
		}
		input = SNAKE_EMPTY;
	}

	start = 0;
	end = 1;

	wait = 0;
	flappy = 1;

	pthread_mutex_lock(&mutex);
	reset = 0;
	pthread_cond_broadcast(&cond);
	pthread_mutex_unlock(&mutex);

	#ifdef GPIO

	pthread_join(th_gpio, NULL);

	#endif /* GPIO */

	pthread_join(th_gravity, NULL);
	pthread_join(th_logic, NULL);
	pthread_join(th_renderer, NULL);
	pthread_cond_destroy(&cond);
	pthread_mutex_destroy(&mutex);

#ifdef GPIO

#ifdef __linux__

	gpio_unexport(GPIO_PIN_IN0);
	gpio_unexport(GPIO_PIN_IN1);
	gpio_unexport(GPIO_PIN_IN2);
	gpio_unexport(GPIO_PIN_IN3);
	gpio_unexport(GPIO_PIN_IN4);
	gpio_unexport(GPIO_PIN_IN5);
	gpio_unexport(GPIO_PIN_IN6);
	gpio_unexport(GPIO_PIN_IN7);
	gpio_unexport(GPIO_PIN_IN8);
	gpio_unexport(GPIO_PIN_IN9);
	gpio_unexport(GPIO_PIN_IN10);
	gpio_unexport(GPIO_PIN_IN11);
	gpio_unexport(GPIO_PIN_IN12);
	gpio_unexport(GPIO_PIN_IN13);
	gpio_unexport(GPIO_PIN_IN14);
	gpio_unexport(GPIO_PIN_IN15);
	gpio_unexport(GPIO_PIN_IN16);
	gpio_unexport(GPIO_PIN_IN17);
	gpio_unexport(GPIO_PIN_IN18);

#endif /* __linux__ */

#endif /* GPIO */

#ifdef SOUND
	Mix_Quit();
#endif /* SOUND */

	TTF_Quit();
	SDL_DestroyRenderer(renderer);
	SDL_DestroyWindow(window);
	SDL_Quit();
}