Created a mainstack datatype. Refactored server game states into separate functions.

6 files changed, 195 insertions, 137 deletions

diff --git a/src/client_game_states.c b/src/client_game_states.c
index 651c06d..1f398ee 100644
--- a/src/client_game_states.c
+++ b/src/client_game_states.c
@@ -54,7 +54,7 @@ game_state_t state_client_wait_for_open_cards(const int sock)
 	return STATE_CLIENT_SELECT_OPEN_CARD;; // just for testing
 }
 
-game_state_t state_client_play_cards(const int sock)
+game_state_t state_client_play_cards(const int sock, const uint8_t round)
 {
 #if 0
 	data_store *d = datamodel();
diff --git a/src/game.c b/src/game.c
index d70f14c..3f6973d 100644
--- a/src/game.c
+++ b/src/game.c
@@ -15,50 +15,7 @@
 #include "net/client.h"
 #include "net/server.h"
 #include "game_states.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;
-}
+#include "main_stack.h"
 
 static void main_loop_client(int sock)
 {
@@ -97,108 +54,25 @@ 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];
 	game_state_t state = STATE_SERVER_DEAL_HAND_CARDS;
 
-	data_store *data = datamodel();
-
-	srand(time(0));
-	init_mainstack(mainstack, cards);
+	main_stack_t m;
+	main_stack_init(&m);
 
 	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;
+				state = state_server_deal_hand_cards(client_socks, round, &m);
 				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
+				state = state_server_wait_for_open_cards(client_socks);
 				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;
-					}
-				}
+				state = state_server_play_cards(client_socks, round);
 				break;
 #endif
 			default:
@@ -226,6 +100,8 @@ void start_game(const bool servermode, const char* addr, const char* port)
 		socket_list_t client_socks;
 		uint8_t num_players = 2;
 
+		srand(time(0)); // Initialize RNG
+
 		data_store* data = datamodel();
 
 		server_sock = server_start(port);
diff --git a/src/game_states.h b/src/game_states.h
index 2c09f76..83950af 100644
--- a/src/game_states.h
+++ b/src/game_states.h
@@ -2,6 +2,8 @@
 #define OXEN_GAME_STATES_H
 
 #include <stdint.h>
+#include "net/server.h"
+#include "main_stack.h"
 
 typedef enum {
 	// Client states
@@ -19,10 +21,10 @@ typedef enum {
 game_state_t state_client_wait_for_hand_cards(const int sock, const uint8_t round);
 game_state_t state_client_select_open_card(const int sock);
 game_state_t state_client_wait_for_open_cards(const int sock);
-game_state_t state_client_play_cards(const int sock);
+game_state_t state_client_play_cards(const int sock, const uint8_t round);
 
-game_state_t state_server_deal_hand_cards();
-game_state_t state_server_wait_for_open_cards();
-game_state_t state_server_play_cards();
+game_state_t state_server_deal_hand_cards(const socket_list_t *client_socks, const uint8_t round, main_stack_t *m);
+game_state_t state_server_wait_for_open_cards(const socket_list_t *client_socks);
+game_state_t state_server_play_cards(const socket_list_t *client_socks, const uint8_t round);
 
 #endif // OXEN_GAME_STATES_H
diff --git a/src/main_stack.c b/src/main_stack.c
new file mode 100644
index 0000000..bae4a88
--- /dev/null
+++ b/src/main_stack.c
@@ -0,0 +1,52 @@
+#include "main_stack.h"
+#include <stdlib.h>
+
+void main_stack_init(main_stack_t *m)
+{
+	assert(m != NULL);
+
+	// assign card values to main stack
+	for(int i = 0; i < MAX_MAIN_STACK_CARDS; i++)
+		m->cards[i] = i + 1;
+
+	// shuffle stack
+	for(int i = 0; i < 3 * MAX_MAIN_STACK_CARDS; i++)
+	{
+		uint32_t x = rand() % MAX_MAIN_STACK_CARDS;
+		uint32_t y = rand() % MAX_MAIN_STACK_CARDS;
+		card tmp = m->cards[x];
+		m->cards[x] = m->cards[y];
+		m->cards[y] = tmp;
+	}
+}
+
+card main_stack_remove_card(main_stack_t *m)
+{
+	assert(m != NULL);
+
+	for(int i = 0; i < MAX_MAIN_STACK_CARDS; i++)
+	{
+		card c = m->cards[i];
+		if(c == 0)
+			continue;
+		m->cards[i] = 0;
+		return c;
+	}
+	return 0; // stack empty
+}
+
+uint8_t main_stack_size(const main_stack_t *m)
+{
+	assert(m != NULL);
+
+	uint8_t count = 0;
+
+	for(uint8_t i = 0; i < MAX_MAIN_STACK_CARDS; i++)
+	{
+		if(m->cards[i] == 0)
+			continue;
+		count++;
+	}
+
+	return count;
+}
diff --git a/src/main_stack.h b/src/main_stack.h
new file mode 100644
index 0000000..aa2d420
--- /dev/null
+++ b/src/main_stack.h
@@ -0,0 +1,18 @@
+#ifndef OXEN_MAIN_STACK_H
+#define OXEN_MAIN_STACK_H
+
+#include <assert.h>
+#include "card.h"
+
+#define MAX_MAIN_STACK_CARDS 104
+
+typedef struct
+{
+	card cards[MAX_MAIN_STACK_CARDS];
+} main_stack_t;
+
+void main_stack_init(main_stack_t *m);
+card main_stack_remove_card(main_stack_t *m);
+uint8_t main_stack_size(const main_stack_t *m);
+
+#endif // OXEN_MAIN_STACK_H
diff --git a/src/server_game_states.c b/src/server_game_states.c
new file mode 100644
index 0000000..c00fc26
--- /dev/null
+++ b/src/server_game_states.c
@@ -0,0 +1,110 @@
+#include "game_states.h"
+#include <stdlib.h>
+#include <string.h>
+#include "global.h"
+
+game_state_t state_server_deal_hand_cards(const socket_list_t *client_socks, const uint8_t round, main_stack_t *m)
+{
+	data_store *d = datamodel();
+
+	if(round == 1)
+	{
+		// Draw cards for initial stacks and send them to clients
+		d->table_stacks.stacks[0].cards[0] = main_stack_remove_card(m);
+		d->table_stacks.stacks[1].cards[0] = main_stack_remove_card(m);
+		d->table_stacks.stacks[2].cards[0] = main_stack_remove_card(m);
+		d->table_stacks.stacks[3].cards[0] = main_stack_remove_card(m);
+
+		for(int i = 0; i < d->players.count; i++)
+		{
+			net_send(client_socks->sockets[i], msg_type_initial_stacks, NULL);
+		}
+	}
+
+	int num_dealcards = main_stack_size(m) / d->players.count;
+	if(num_dealcards > 10)
+		num_dealcards = 10;
+
+	// Deal hand cards to clients
+	for(int i = 0; i < d->players.count; i++)
+	{
+		hand_t h;
+		memset(h.cards, 0, MAX_HAND_CARDS);
+
+		for(int j = 0; j < num_dealcards; j++)
+			h.cards[j] = main_stack_remove_card(m);
+
+		hand_sort(&h);
+
+		net_send(client_socks->sockets[i], msg_type_deal_hand, &h);
+	}
+
+	return STATE_SERVER_WAIT_FOR_OPEN_CARDS;
+}
+
+game_state_t state_server_wait_for_open_cards(const socket_list_t *client_socks)
+{
+	data_store *d = datamodel();
+
+	// Receive open cards from clients
+	for(int i = 0; i < d->players.count; i++)
+	{
+		pnoc_t* pl = get_pnoc_from_playerid(&d->players, client_socks->player_ids[i]);
+		assert(pl != NULL);
+		net_recv(client_socks->sockets[i], msg_type_selected_card);
+		pl->open_card = d->selected_card;
+	}
+
+	for(int i = 0; i < d->players.count; i++)
+		net_send(client_socks->sockets[i], msg_type_selected_card_all, NULL);
+
+	//return STATE_SERVER_PLAY_CARDS;
+	return STATE_SERVER_WAIT_FOR_OPEN_CARDS; // just for testing
+}
+
+game_state_t state_server_play_cards(const socket_list_t *client_socks, const uint8_t round)
+{
+#if 0
+	data_store *d = datamodel();
+
+	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)
+	{
+		return STATE_SERVER_WAIT_FOR_OPEN_CARDS;
+	}
+	else
+	{
+		if (main_stack_has_enough_cards_for_clients)
+		{
+			send_action_to_client(DEAL_HAND_CARDS);
+			round++;
+			return STATE_SERVER_DEAL_HAND_CARDS;
+		}
+		else
+		{
+			send_action_to_client(GAME_FINISHED);
+			return STATE_SERVER_GAME_FINISHED;
+		}
+	}
+#endif
+	return 1337;
+}