path: root/src/client.c

#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
#include <poll.h>
#include <errno.h>
#include <ctype.h>
#include <stdint.h>
#include "str.h"
#include "ser.h"
#include "net.h"
#include "ticker.h"
#include "sig.h"
#include "content.h"
#include "chunk.h"

typedef struct {
	str name;
	uint64_t id;
} player;

typedef struct {
	peer conn;
	struct termios oldtio;
	str name;
	str pass;
	uint64_t self_id;
	array(player) players;
	str server_motd;
	chunk map;
	node *map_swap;
	vec2 player_pos;
} client;

void gfx_alt_buffer(bool enable)
{
	if (enable)
		printf("\e[?1049h\e[?25l");
	else
		printf("\e[?1049l\e[?25h");
}

void gfx_clear_effects()
{
	printf("\e[0m");
}

void gfx_set_color(color c, bool bg)
{
	printf("\e[%u;2;%u;%u;%um", bg ? 48 : 38, c.r, c.g, c.b);
}

void gfx_clear()
{
	printf("\e[2J");
}

void gfx_render(client *c, uint64_t dtime)
{
	gfx_clear();
	printf("\e[H");
	printf("%.*s\n", PSTR(c->server_motd));
	for (size_t i = 0; i < c->players.len; i++)
		printf("%.*s\n", PSTR(c->players.data[i].name));
	for (size_t y = 0; y < c->map.bounds.size.y; y++) {
		for (size_t x = 0; x < c->map.bounds.size.y; x++) {
			node *n = chunk_index(c->map, UVEC2(x, y));
			if (!n->present) {
				gfx_set_color(color_from_u32(0x555555), true);
				gfx_set_color(color_from_u32(0xffffff), false);
				printf("??");
			} else {
				gfx_set_color(n->col, true);
				printf("  ");
			}
		}
		gfx_clear_effects();
		printf("\n");
	}
	fflush(stdout);
}

void free_players(client *c)
{
	for (size_t i = 0; i < c->players.len; i++)
		free(c->players.data[i].name.data);

	free(c->players.data);

	c->players.len = 0;
	c->players.data = NULL;
}

void client_exit(client *c, int ret)
{
	free(c->name.data);
	free(c->pass.data);
	free(c->server_motd.data);

	free_players(c);

	peer_free(&c->conn);
	tcsetattr(STDIN_FILENO, TCSANOW, &c->oldtio);
	gfx_alt_buffer(false);
	fflush(stdout);

	exit(ret);
}

void handle_input(client *c, char ch)
{
	ch = tolower(ch);
	switch (ch) {
		case 'q': client_exit(c, EXIT_SUCCESS); break;
		default: break;
	}
}

void map_set_center(client *c, vec2 center)
{
	chunk old = c->map;

	c->map.data = c->map_swap;
	c->map.bounds.pos = center;
	c->map_swap = old.data;

	chunk_clear(c->map);
	chunk_copy(c->map, old);
}

bool deser_color(str *r, color *c)
{
	return deser_u8(r, &c->r) && deser_u8(r, &c->g) && deser_u8(r, &c->b);
}

bool deser_node(str *r, node *n)
{
	if (!deser_bool(r, &n->present)) return false;
	if (!n->present) return true;

	return deser_i8(r, &n->z)
		&& deser_color(r, &n->col);
}

bool handle_nodes(str *pkt, client *c)
{
	chunk ch;
	if (!deser_vec2(pkt, &ch.bounds.pos)) return false;
	if (!deser_uvec2(pkt, &ch.bounds.size)) return false;

	if (ch.bounds.size.x * ch.bounds.size.y > NODES_PKT_MAX) return false;

	node nodes[ch.bounds.size.x * ch.bounds.size.y];
	ch.pitch = ch.bounds.size.y;
	ch.data = nodes;

	for (uint32_t x = 0; x < ch.bounds.size.x; x++)
	for (uint32_t y = 0; y < ch.bounds.size.y; y++)
		if (!deser_node(pkt, chunk_index(ch, UVEC2(x, y)))) return false;

	chunk_copy(c->map, ch);
	return true;
}

bool handle_reset_map(str *pkt, client *c)
{
	(void) pkt;
	chunk_clear(c->map);
	return true;
}

bool handle_players(str *pkt, client *c)
{
	free_players(c);

	uint16_t len;
	if (!deser_u16(pkt, &len)) return false;

	c->players.data = malloc(sizeof *c->players.data * len);

	for (c->players.len = 0; c->players.len < len; c->players.len++) {
		player *p = &c->players.data[c->players.len];
		if (!deser_str(pkt, &p->name)) return false;
		if (!deser_u64(pkt, &p->id)) return false;
		if (str_eq(p->name, c->name))
			c->self_id = p->id;
		p->name = str_clone(p->name);
	}
	return true;
}

bool handle_hi(str *w, client *c)
{
	str motd;
	if (!deser_str(w, &motd)) return false;

	c->server_motd = str_clone(motd);
	return true;
}

bool handle_pkt(client *c, str pkt)
{
	pkt_type type;
	if (!deser_pkt_type(&pkt, &type))
		return false;

	switch (type) {
		case CPKT_HI: return handle_hi(&pkt, c);
		case CPKT_PLAYERS: return handle_players(&pkt, c);
		case CPKT_RESET_MAP: return handle_reset_map(&pkt, c);
		case CPKT_NODES: return handle_nodes(&pkt, c);
		default: return false;
	}
}

int main(int argc, char **argv)
{
	if (argc < 4) {
		fprintf(stderr, "usage: %s server port name [pass]\n", argv[0]);
		return EXIT_FAILURE;
	}

	signal_setup();

	client c = {0};

	const char *server = argv[1];
	const char *port = argv[2];
	c.name = str_clone(str_intro(argv[3]));
	c.pass = str_clone(argc < 5 ? S("") : str_intro(argv[4]));

	c.conn.socket = -1;

	tcgetattr(STDIN_FILENO, &c.oldtio); // TODO: handle error

	struct termios newtio = c.oldtio;
	newtio.c_lflag &= ~(ICANON | ECHO);
	tcsetattr(STDIN_FILENO, TCSANOW, &newtio); // TODO: handle error

	SET_NONBLOCK(STDIN_FILENO); // TODO: handle error

	int socket = socket_create(server, port, false);
	if (socket < 0)
		client_exit(&c, EXIT_FAILURE);
	str server_name = S("server");
	peer_init(&c.conn, socket, &server_name);

	setvbuf(stdout, NULL, _IOFBF, 0);
	gfx_alt_buffer(true);

	SEND_PKT(c.conn, SPKT_HI,
		ser_str(&pkt, c.name);
		ser_str(&pkt, c.pass);
	)

	c.map = chunk_alloc(box2_around(VEC2(0, 0), SIGHT_RANGE));
	c.map_swap = malloc(c.map.bounds.size.x * c.map.bounds.size.y * sizeof(node));

	ticker t;
	ticker_init(&t, NANOS/60);

	for (;;) {
		struct pollfd fds[2];

		fds[0].fd = STDIN_FILENO;
		fds[0].events = POLLIN;

		fds[1] = peer_prepare(&c.conn);

		if (poll(fds, 2, ticker_timeout(&t)) < 0) {
			switch (errno) {
				case EINTR: break;
				default: perror("poll"); continue;
			}
		}

		if (signal_stop)
			client_exit(&c, EXIT_SUCCESS);

		if (fds[0].revents) {
			// this is cursed
			// maybe dont do this idk
			char ch;
			errno = 0;
			while (read(STDIN_FILENO, &ch, 1) == 1)
				handle_input(&c, ch);
			switch (errno) {
				case 0: case EWOULDBLOCK: case EINTR: break;
				default: perror("read"); break;
			}
		}

		str pkt = peer_recv(&c.conn, fds[1]);
		if (c.conn.disco)
			client_exit(&c, EXIT_SUCCESS);
		if (pkt.len > 0 && !handle_pkt(&c, pkt))
			invalid_pkt(&c.conn, pkt);

		uint64_t dtime;
		if (ticker_tick(&t, &dtime))
			gfx_render(&c, dtime);
	}
}