path: root/src/game.c

#include "game.h"
#include "card.h"
#include "hand.h"
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <assert.h>
#include <curses.h>
#include <sys/types.h>
#include "ui.h"
#include "global.h"
#include "net/comm.h"
#include "net/client.h"
#include "net/server.h"

static void init_mainstack(card *stack, const uint32_t size)
{
	assert(stack != NULL);

	// assign card values to main stack
	for(uint32_t i=0, val=MIN_CARD; i<size; i++, val++)
		stack[i] = val;

	// shuffle stack
	for(uint32_t i=0; i<3*size; i++)
	{
		uint32_t x = rand() % size;
		uint32_t y = rand() % size;
		card tmp = stack[x];
		stack[x] = stack[y];
		stack[y] = tmp;
	}
}

static const card mainstack_remove_card(card *stack, const uint32_t size)
{
	for(uint32_t i=0; i<size; i++)
	{
		card c = stack[i];
		if(c == 0)
			continue;
		stack[i] = 0;
		return c;
	}
	return 0; // stack empty
}

static const uint8_t num_cards_in_stack(const card *stack, const uint32_t size)
{
	uint8_t count = 0;
	for(int i=0; i<size; i++)
	{
		if(stack[i] == 0)
			continue;
		count++;
	}
	return count;
}

static void main_loop_client(int sock)
{
	bool running = true;
	gamestate state = STATE_CLIENT_WAIT_FOR_HAND_CARDS;
	uint8_t round = 1;
	data_store *data = datamodel();
	uint8_t open_card_idx;
	uint8_t picked_stack_idx;

	while(running)
	{
		switch(state)
		{
			case STATE_CLIENT_WAIT_FOR_HAND_CARDS:
				if(round == 1)
				{
					// Receive and display table stacks
					net_recv(sock, msg_type_initial_stacks);
					ui_display_wnd_table_cards(&data->table_stacks, false, 0);
					ui_display_wnd_stack_points(&data->table_stacks, false, 0);
				}

				// Wait for hand cards from server and display them
				net_recv(sock, msg_type_deal_hand);
				ui_display_wnd_hand_cards(&data->hand, false, 0);

				state = STATE_CLIENT_SELECT_OPEN_CARD;
				break;

			case STATE_CLIENT_SELECT_OPEN_CARD:
				// Select open card
				open_card_idx = ui_choose_card(&data->hand);
				data->selected_card = data->hand.cards[open_card_idx];

				// Send open card to server
				net_send(sock, msg_type_selected_card, NULL);

				// Remove picked open card from hand
				hand_remove_card(&data->hand, open_card_idx);
				ui_display_wnd_hand_cards(&data->hand, false, 0);

				state = STATE_CLIENT_WAIT_FOR_OPEN_CARDS;
				break;

			case STATE_CLIENT_WAIT_FOR_OPEN_CARDS:
				net_recv(sock, msg_type_selected_card_all);
				pnoc_sort(data->players.players, data->players.count); // sort in ascending order

				ui_display_wnd_current_state(data->players.players, data->players.count, true, 0, 0); // TODO fix parameters

				//state = STATE_CLIENT_PLAY_CARDS;
				//sleep(2);
				//return;
				state = STATE_CLIENT_SELECT_OPEN_CARD;; // just for testing
				break;

#if 0
			case STATE_CLIENT_PLAY_CARDS:
				foreach(open_card)
				{
					play_lowest_open_card
					{
						determine_stack_for_open_card
						{
							if (stack_has_to_be_picked)
							{
								if (we_have_to_pick)
								{
									pick_stack();
									send_stack_to_server();
								}
								else // another client has to pick
								{
									receive_stack();
								}

								clear_stack(stack_id);
							}
						}
						place_card()
						{
							if(count_stack_cards == 6)
								clear_stack(stack_id);
						}
					}

				}
				if (we_have_hand_cards)
				{
					state = STATE_CLIENT_SELECT_OPEN_CARD;
				}
				else
				{
					receive_next_server_action();
					if (server_action == DEAL_CARDS)
					{
						round++;
						state = STATE_CLIENT_WAIT_CARDS;
					}
					else if (server_action == GAME_FINISHED)
						state = STATE_CLIENT_GAME_FINISHED;
				}
				break;
#endif
			default:
				printf("main_loop_client: entered unknown state\n");
				exit(EXIT_FAILURE);
		}
	}
}

static void main_loop_server(socket_list_t* client_socks)
{
	bool running = true;
	uint8_t round = 1;
	int cards = MAX_CARD - MIN_CARD + 1;
	card mainstack[cards];
	gamestate state = STATE_SERVER_DEAL_HAND_CARDS;

	data_store *data = datamodel();

	srand(time(0));
	init_mainstack(mainstack, cards);

	while(running)
	{
		switch(state)
		{
			case STATE_SERVER_DEAL_HAND_CARDS:
				if(round == 1)
				{
					// Draw cards for initial stacks and send them to clients
					data->table_stacks.stacks[0].cards[0] = mainstack_remove_card(mainstack, cards);
					data->table_stacks.stacks[1].cards[0] = mainstack_remove_card(mainstack, cards);
					data->table_stacks.stacks[2].cards[0] = mainstack_remove_card(mainstack, cards);
					data->table_stacks.stacks[3].cards[0] = mainstack_remove_card(mainstack, cards);
					for(int i = 0; i < data->players.count; i++)
					{
						net_send(client_socks->sockets[i], msg_type_initial_stacks, NULL);
					}
				}

				int num_dealcards = num_cards_in_stack(mainstack, cards) / data->players.count;
				if(num_dealcards > 10)
					num_dealcards = 10;

				// Deal hand cards to clients
				for(int i = 0; i < data->players.count; i++)
				{
					hand_t h;
					memset(h.cards, 0, MAX_HAND_CARDS);
					for(int j=0; j<num_dealcards; j++)
						h.cards[j] = mainstack_remove_card(mainstack, cards);
					hand_sort(&h);

					net_send(client_socks->sockets[i], msg_type_deal_hand, &h);
				}

				state = STATE_SERVER_WAIT_FOR_OPEN_CARDS;
				break;

			case STATE_SERVER_WAIT_FOR_OPEN_CARDS:
				// Receive open cards from clients
				for(int i = 0; i < data->players.count; i++)
				{
					pnoc_t* pl = get_pnoc_from_playerid(&data->players, client_socks->player_ids[i]);
					assert(pl != NULL);
					net_recv(client_socks->sockets[i], msg_type_selected_card);
					pl->open_card = data->selected_card;
				}

				for(int i=0; i<data->players.count; i++)
					net_send(client_socks->sockets[i], msg_type_selected_card_all, NULL);

				//state = STATE_SERVER_PLAY_CARDS;
				state = STATE_SERVER_WAIT_FOR_OPEN_CARDS; // just for testing
				break;
#if 0
			case STATE_SERVER_PLAY_CARDS:
				foreach(open_card)
				{
					play_lowest_open_card
					{
						determine_stack_for_open_card
						{
							if (stack_has_to_be_picked) {
								receive_stack_from_client();
								send_received_stack_to_other_clients();
								clear_stack(stack_id);
							}
						}
						place_card()
						{
							if(count_stack_cards == 6)
								clear_stack(stack_id);
						}
					}

				}
				if (clients_have_hand_cards)
				{
					state = STATE_SERVER_WAIT_FOR_OPEN_CARDS;
				}
				else
				{
					if (main_stack_has_enough_cards_for_clients)
					{
						send_action_to_client(DEAL_HAND_CARDS);
						round++;
						state = STATE_SERVER_DEAL_HAND_CARDS;
					}
					else
					{
						send_action_to_client(GAME_FINISHED);
						state = STATE_SERVER_GAME_FINISHED;
					}
				}
				break;
#endif
			default:
				printf("main_loop_server: entered unknown state\n");
				exit(EXIT_FAILURE);
		}
	}
}

void start_game(const bool servermode, const char* addr, const char* port)
{
	assert(addr != NULL && port != NULL);

	bool server_process = false;

	if(servermode)
	{
		pid_t child = fork();
		server_process = (child > 0);
	}

	if(server_process) // Start server and connect to localhost
	{
		int server_sock;
		socket_list_t client_socks;
		uint8_t num_players = 2;

		data_store* data = datamodel();

		server_sock = server_start(port);
		server_get_players(server_sock, &client_socks, num_players);
		data->players.count = num_players;

		for(int i=0; i<num_players; i++)
		{
			net_recv(client_socks.sockets[i], msg_type_hello);
			// assign ids (starting with 1; 0 is invalid)
			client_socks.player_ids[i] = i+1;
			data->players.players[i].player_id = i+1;
			printf("Player connected: %s\n", data->players.players[i].player_name);
		}

		for(int i=0; i<num_players; i++)
		{
			net_send(client_socks.sockets[i], msg_type_start_game, NULL);
		}

		main_loop_server(&client_socks);
	}
	else // Connect to server
	{
		int sock;

		sleep(1); // TODO make sure server process is listening
		sock = client_connect_server(addr, port);
		data_store* data = datamodel();

		strncpy(data->nickname, "nickname", 10);
		net_send(sock, msg_type_hello, NULL);
		net_recv(sock, msg_type_start_game);

		ui_init();

		// Display all windows
		ui_display_wnd_table_cards(&data->table_stacks, false, 0);
		ui_display_wnd_stack_points(&data->table_stacks, false, 0);
		ui_display_wnd_current_state(data->players.players, data->players.count, false, 0, 0);
		ui_display_wnd_hand_cards(&data->hand, false, 0);

		main_loop_client(sock);

		ui_fini();
	}
}