From eb90648bdad1443c9cfc72e903a93642e10a0ab7 Mon Sep 17 00:00:00 2001 From: scratko Date: Fri, 16 Aug 2024 18:10:11 +0300 Subject: Global fixes v2.0 Added spectator mode. Added screen of game result. Added definition of durak. If not all players can replenish their decks, they take cards one at a time in turn. --- server/server_game_process.c | 101 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 87 insertions(+), 14 deletions(-) (limited to 'server/server_game_process.c') diff --git a/server/server_game_process.c b/server/server_game_process.c index 46a9535..d6fc4be 100644 --- a/server/server_game_process.c +++ b/server/server_game_process.c @@ -52,15 +52,15 @@ void deal_first_cards(const char **shuffled_deck, int *cards_left, } void deal_cards(const char **shuffled_deck, int *shuffled_cards_left, - struct session **turn_queue, int players_number, - int *card_quantity_arr) + struct session **turn_queue, int turn_queue_size, + int *number_arr) { int i, j, key, player_deck_size, card_shortage_quantity, last_idx; const char *extracted_card = NULL; - for(i = 0; i < players_number; ++i) { + for(i = 0; i < turn_queue_size; ++i) { key = turn_queue[i]->player_position - 1; - player_deck_size = card_quantity_arr[key]; + player_deck_size = number_arr[key]; if(player_deck_size < start_deck_size) { card_shortage_quantity = start_deck_size - player_deck_size; for(j = 0; j < card_shortage_quantity; ++j) { @@ -77,6 +77,32 @@ void deal_cards(const char **shuffled_deck, int *shuffled_cards_left, } } +void deal_one_card_in_turn(const char **shuffled_deck, int *shuffled_cards_left, + struct session **turn_queue, int turn_queue_size, + struct card_count cc) +{ + int i, key, player_deck_size, last_idx; + const char *extracted_card = NULL; + + while(*shuffled_cards_left) { + update_card_quantity_arr(turn_queue, cc); + for(i = 0; i < turn_queue_size; ++i) { + key = turn_queue[i]->player_position - 1; + player_deck_size = cc.number_arr[key]; + if(player_deck_size < start_deck_size) { + last_idx = *shuffled_cards_left-1; + /* shuffled deck is empty */ + if(last_idx < 0) + return; + extracted_card = shuffled_deck[last_idx]; + push_stack(&turn_queue[i]->deck, extracted_card); + --*shuffled_cards_left; + shuffled_deck[last_idx] = NULL; + } + } + } +} + const char* extract_trump_card(const char **shuffled_deck, int *cards_left) { const char *trump_card = NULL; @@ -148,34 +174,49 @@ int find_lowest_trump(player_cards deck, const char *trump_suit) } return lowest_rank; } - -void shift_turn_queue_by_one(struct session **turn_queue, int size) +/* + * used to transition attack to defender + */ +void shift_turn_queue_by_one(struct session **turn_queue, int turn_queue_size) { int i; struct session *tmp = turn_queue[0]; - for(i = 1; i < size; ++i) + for(i = 1; i < turn_queue_size; ++i) turn_queue[i-1] = turn_queue[i]; turn_queue[i-1] = tmp; } -void move_turn_queue_two_players_ahead(struct session **turn_queue, int size) +/* + * used to transition the attack to player behind defender + */ +void move_turn_queue_two_players_ahead(struct session **turn_queue, + int turn_queue_size) { int i; for(i = 0; i < 2; ++i) - shift_turn_queue_by_one(turn_queue, size); + shift_turn_queue_by_one(turn_queue, turn_queue_size); } -void update_card_quantity_arr(struct server *serv) +void update_card_quantity_arr(struct session **turn_queue, struct card_count cc) { - int i, player_position_idx; + int i, key; + for(i = 0; i <= cc.number_arr_idx; ++i) { + key = turn_queue[i]->player_position - 1; + cc.number_arr[key] = + find_out_card_quantity_in_deck(turn_queue[i]->deck); + } + + +#if 0 for(i = 0; i < serv->max_sess_arr_size; ++i) if(serv->sess_arr[i]) { player_position_idx = serv->sess_arr[i]->player_position - 1; serv->cc.number_arr[player_position_idx] = find_out_card_quantity_in_deck(serv->sess_arr[i]->deck); } +#endif } struct game_info* get_new_game_info(int players_number, int *card_quantity_arr, @@ -358,7 +399,7 @@ static int check_matched_ranks(const char *attack_card, } int check_someone_can_toss_card(struct session **turn_queue, - int players_quantity, + int players_quantity, /* like turn_queue_size */ struct card_queue *cq, struct cards_on_table *cot) { @@ -523,11 +564,12 @@ int calculate_attack_card_quantity_on_table(const struct cards_on_table *cot) return counter; } -int check_all_answers_were_received(const struct session **turn_queue, int size) +int check_all_answers_were_received(const struct session **turn_queue, + int turn_queue_size) { int i; - for(i = 0; i < size; ++i) + for(i = 0; i < turn_queue_size; ++i) if(turn_queue[i]->tm == answer_wait) return 0; return 1; @@ -558,3 +600,34 @@ void clear_defense_lost_status(struct session *defender) { defender->defense_lost = 0; } +/* + * can everyone fully replenish their deck (up to 6 cards)? + */ +int check_everyone_can_replanish_deck(int shuffled_cards_left, + struct session **turn_queue, + int turn_queue_size, int *number_arr) +{ + int i, key, player_deck_size; + + for(i = 0; i < turn_queue_size; ++i) { + key = turn_queue[i]->player_position - 1; + player_deck_size = number_arr[key]; + if(player_deck_size < start_deck_size) + shuffled_cards_left -= start_deck_size - player_deck_size; + } + return shuffled_cards_left >= 0; +} +#if 0 +void find_out_who_dropped_all_cards(struct session **turn_queue, + int turn_queue_size, int *number_arr) +{ + int i, key, player_deck_size; + + for(i = 0; i < turn_queue_size; ++i) { + key = turn_queue[i]->player_position - 1; + player_deck_size = number_arr[key]; + if(!player_deck_size) + turn_queue[i]->state = discarded_cards; + } +} +#endif -- cgit v1.2.3