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.

1 files changed, 87 insertions, 14 deletions

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