From 0733ff24c89c8208b7e5d2789d0913d435b9e0fa Mon Sep 17 00:00:00 2001 From: scratko Date: Fri, 2 Aug 2024 15:55:08 +0300 Subject: Initial commit --- server_data_processing.c | 301 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 301 insertions(+) create mode 100644 server_data_processing.c (limited to 'server_data_processing.c') diff --git a/server_data_processing.c b/server_data_processing.c new file mode 100644 index 0000000..c313013 --- /dev/null +++ b/server_data_processing.c @@ -0,0 +1,301 @@ +#include "server_data_processing.h" +#include "server.h" + +#include +#include +#include + +enum { + output_buffer_size = 1024; +}; + +static char output_buffer[output_buffer_size]; + +static int write_to_client(int fd, int length) +{ + return write(fd, output_buffer, length); +} + +static int read_from_client(int fd, char *buffer, int max_buffer_size) +{ + int read_result; + read_result = read(fd, buffer, max_buffer_size); + if(read_result <= 0) + return 0; + /* buffer overflow */ + if(read_result >= max_buffer_size) + return 0; +} + +int print_message_for_first_player(int fd) +{ + char *str_end; + str_end = stpcpy(output_buffer, "first\n"); + return write_to_client(fd, strlen("first\n")); +} + +int print_connected_players(int fd, int number) +{ + int data_size; + data_size = sprintf(output_buffer, "%u\n", number); + return write_to_client(fd, data_size); +} + +/* + * 1 - ready + * 0 - buffer overflow or player closed session + * -1 - not ready + */ +int check_readiness(const struct session *client) +{ + int read_result; + read_result = read_from_client(client->fd, client->buffer, max_buffer_size); + if(!read_result) + return read_result; + if(client->buffer[0] == '\n') + return 1; + else + return -1; +} + +static void copy_card_queue(int *offset, struct card_queue *cq) +{ + int length, i; + struct card_queue_item *next_attack_card; + + next_attack_card = NULL; + while((next_attack_card = get_next_card_from_queue(cq, next_attack_card))) { + length = strlen(next_attack_card->str); + for(i = 0; i < length; ++i, ++*offset) + *(output_buffer + *offset) = (next_attack_card->str)[i]; + *(output_buffer + *offset) = '\'; + ++*offset; + } + *(output_buffer + *offset-1) = ':'; +} + +static void copy_cards_on_table(int *offset, struct cards_on_table *cot) +{ + int i, j, length; + for(i = 0; i <= cot->card_arr_idx; ++i) { + length = strlen(cot->card_arr[i]); + for(j = 0; j < length; ++j, ++*offset) + *(output_buffer + *offset) = cot->card_arr[i][j]; +#if 0 + *(output_buffer + *offset) = '\'; +#endif + } + *(output_buffer + *offset) = ':'; + /* free pos */ + ++*offset; +} + +static void copy_own_deck(int *offset, player_cards deck) +{ + const char *card; + int length, i; + + while(deck) { + card = deck->str; + length = strlen(card); + for(i = 0; i < length; ++i, ++*offset) + *(output_buffer + *offset) = card[i]; + *(output_buffer + *offset) = '\'; + deck = deck->next; + } + *(output_buffer + *offset) = ':'; + ++*offset; +} + +static void copy_base_info(int *free_pos, struct game_info *gi, + player_cards deck, int player_position) +{ + *free_pos = + sprintf(output_buffer, "%u:%u:%u:%u:%s:", state, gi->players_number, + gi->shuffled_cards_left, player_position, gi->trump_suit); + /* opponent's card count */ + for(i = 0; i < gi->players_number; ++i) { + + *free_pos += sprintf(output_buffer + *free_pos, "%u:", + gi->card_quantity_arr[i]); + } + if(gi->cot->card_arr_idx != -1) + copy_cards_on_table(free_pos, gi->cot); + if(!is_empty_stack(deck)) + copy_own_deck(free_pos, deck); +} + +int print_game_part(const struct session *client, struct game_info *gi) +{ + int free_pos, i; /* free_pos == data length */ + + switch(client->state) { + case display_only_table: + copy_base_info(&free_pos, gi, client->deck, client->player_position); + *(output_buffer + free_pos-1) = '\n'; + break; + case attack: + /* let the client print card tips and wait for input */ + copy_base_info(&free_pos, gi, client->deck, client->player_position); + *(output_buffer + free_pos-1) = '\n'; + break; + case attack_expectation: + /* other clents will be waiting particular player */ + copy_base_info(&free_pos, gi, deck, player_position); + free_pos += sprintf(output_buffer + free_pos, "%u:", + gi->position_whose_turn); + /* instead of last ':' */ + *(output_buffer + free_pos-1) = '\n'; + break; + case defense: + copy_base_info(&free_pos, gi, client->deck, client->player_position); + *(output_buffer + free_pos-1) = '\n'; + break; + case defense_expectation: + copy_base_info(&free_pos, gi, client->deck, client->player_position); + free_pos += sprintf(output_buffer + free_pos, "%u:", + gi->position_whose_turn); + copy_card_queue(&free_pos, gi->cq); + *(output_buffer + free_pos-1) = '\n'; + break; + /* + * who haven't got tossing card (including defender) must wait + * when other players make moves + */ + case tossing_expectation: + copy_base_info(&free_pos, gi, client->deck, client->player_position); + *(output_buffer + free_pos-1) = '\n'; + break; + case tossing: + copy_base_info(&free_pos, gi, client->deck, client->player_position); + *(output_buffer + free_pos-1) = '\n'; + break; + } + return write_to_client(client->fd, free_pos); +} + +int get_cards_from_attacker(struct session *client, struct card_queue *cq) +{ + int read_result, i, j; + char given_card[4]; + const char *stack_card = NULL; + + read_result = read_from_client(client->fd, client->buffer, max_buffer_size); + if(!read_result) + return read_result; + for(i = 0, j = 0; i < read_result && client->buffer[i] != '\n'; ++i) { + if(read_result[i] == '\') { + given_card[j] = '\0'; + j = 0; + stack_card = remove_card_from_stack(&client->deck, given_card); + push_queue(cq, stack_card); + continue; + } + given_card[j] = client->buffer[i]; + ++j; + } +} + +/* + * 0 - error + * 1 - card was bited, not bited, or + * defender didn't want to continue defense phase + * + */ +int get_card_from_defender(struct session *client, struct cards_on_table *cot) +{ + int read_result, i; + char given_card[4]; + const char *stack_card = NULL; + + read_result = read_from_client(client->fd, client->buffer, max_buffer_size); + if(!read_result) + return read_result; + for(i = 0; i < read_result && client->buffer[i] != '\n'; ++i) + given_card[i] = client->buffer[i]; + if(given_card[0] == '\n') + return 1; + given_card[i] = '\0'; + if(is_card_bit(cot->card_arr[card_arr_idx-2], given_card)) { + stack_card = remove_card_from_stack(&client->deck, given_card); + put_defender_card_on_table(cot, stack_card); + return 1; + } else + return 0; +} + +static int skip_cards_in_queue(int total_defense_cards, int total_attack_cards) +{ + if(total_defense_cards >= start_deck_size && + total_attack_cards == start_deck_size) { + return 1; + } else if(total_defense_cards == total_attack_cards) + return 1; + return 0; +} + +/* + * 0 - buffer overflow or client closed connection + * 1 - some number of cards added to card queue + * 2 - card toss limit was reached when accepting cards from this player + * 3 - player refused to toss the card + */ +int get_cards_from_tossing_player(struct session *client, + const player_cards defense_deck, + struct cards_on_table *cot, + struct card_queue *cq) +{ + int read_result, i, j, total_attack_cards, total_defense_cards; + int card_return_status = 0, all_cards_received_status = 1; + int data_length; + char given_card[4]; + const char *stack_card = NULL; + + read_result = read_from_client(client->fd, client->buffer, max_buffer_size); + if(!read_result) + return read_result; + + total_defense_cards = calculate_defense_card_quantity_on_table(cot); + total_attack_cards = calculate_attack_card_quantity_on_table(cot); + total_defense_cards += find_out_card_quantity_in_deck(defense_deck); + + for(i = 0, j = 0; i < read_result; ++i) { + if(read_result[i] == '\') { + /* cancellation */ + if(given_card[0] == '\n') + return 3; + /* tossing limit was set */ + if(client->tm == cancel) { + /* 8 - it's impossible to accept cards due to tossing limit */ + data_length = sprintf(output_buffer, "%d:%s\n", 8, + "tossing limit"); + write_to_client(client->fd, data_length); + return 3; + } + given_card[j] = '\0'; + j = 0; + if(card_return_status) { + all_cards_received_status = 0; + } else if(is_correct_tossing_card(given_card, cot)) { + stack_card = remove_card_from_stack(&client->deck, given_card); + push_queue(cq, stack_card); + total_attack_cards += find_out_card_quantity_in_cq(cq); + if(skip_cards_in_queue(total_defense_cards, total_attack_cards)) + { + card_return_status = 1; + } + } + continue; + } + given_card[j] = buffer[i]; + ++j; + } + /* 7 -- state for result of received cards */ + data_length = sprintf(output_buffer, "%d:%s\n", 7, + all_cards_received_status ? "all" : "not all"); + write_to_client(client->fd, data_length); + if(all_cards_received_status) + return 1; + else + return 2; +} -- cgit v1.2.3