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.

6 files changed, 323 insertions, 86 deletions

diff --git a/server/server.c b/server/server.c
index b2f1c3b..1655448 100644
--- a/server/server.c
+++ b/server/server.c
@@ -7,7 +7,6 @@
 #include <fcntl.h>
 #include <syslog.h>
 #include <time.h>
-#include <netinet/tcp.h>
 
 #include "server.h"
 #include "server_data_processing.h"
@@ -35,7 +34,6 @@ static int accept_client(struct server *serv)
     struct session *new_session;
     socklen_t len = sizeof(addr);
     fd = accept(serv->listen_socket, (struct sockaddr*) &addr, &len);
-    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (int[]){1}, sizeof(int));
     if(fd == -1)
         return -1;
 
@@ -56,6 +54,10 @@ static int accept_client(struct server *serv)
     return 1;
 }
 
+static void close_connection(struct server *serv)
+{
+}
+
 static int check_playable_player_number(struct server *serv)
 {
     return serv->connected_players_counter >= 2 &&
@@ -84,6 +86,7 @@ static void init_new_game(struct server *serv)
 #endif
     serv->turn_queue = malloc(sizeof(struct session*) *
                               serv->connected_players_counter);
+    serv->turn_queue_size = serv->connected_players_counter;
     /* number of cards each player holds */
     serv->cc.number_arr_idx = serv->connected_players_counter - 1;
     serv->cc.number_arr = malloc(sizeof(int) * serv->connected_players_counter);
@@ -117,13 +120,15 @@ static void init_new_game(struct server *serv)
     for(i = 0; i < who_attack; ++i)
         shift_turn_queue_by_one(serv->turn_queue,
                                   serv->connected_players_counter);
-    update_card_quantity_arr(serv);
+    update_card_quantity_arr(serv->turn_queue, serv->cc);
     init_queue(&serv->cq);
     serv->gi = get_new_game_info(serv->connected_players_counter,
                                  serv->cc.number_arr,
                                  serv->shuffled_deck_size,
                                  serv->trump_card, serv->position_whose_turn,
                                  &serv->cq, &serv->cot);
+    serv->durak_position = 0;
+    serv->tossing_limit = 0;
 }
 
 static void set_whose_turn(struct server *serv, enum client_game_states state)
@@ -141,6 +146,9 @@ static void set_whose_turn(struct server *serv, enum client_game_states state)
     }
 }
 
+/*
+ * state set during game play
+ */
 static void set_state_for_client(struct server *serv,
                                  enum client_game_states state)
 {
@@ -159,7 +167,10 @@ static void set_state_for_client(struct server *serv,
         {}
     }
 
-    for(i = 0; i < serv->connected_players_counter; ++i) {
+    for(i = 0; i < serv->turn_queue_size; ++i) {
+        if(serv->turn_queue[i]->state == spectator)
+            continue;
+
         switch(state) {
         case attack:
             if(serv->turn_queue[i] && serv->turn_queue[i] !=
@@ -193,6 +204,11 @@ static void set_state_for_client(struct server *serv,
             {}
         }
     }
+    /* end of game */
+    if(state == result)
+        for(i = 0; i < serv->max_sess_arr_size; ++i)
+            if(serv->sess_arr[i])
+                serv->sess_arr[i]->state = result;
 }
 
 static void set_record_status_for_all(struct server *serv)
@@ -258,7 +274,7 @@ static void define_phase_after_defense(struct server *serv)
         if(!is_receiving_cards_limit(&serv->cot, serv->turn_queue[1]->deck,
                                      &serv->cq) &&
             check_someone_can_toss_card(serv->turn_queue,
-                                       serv->connected_players_counter,
+                                       serv->turn_queue_size,
                                        &serv->cq, &serv->cot))
         {
             set_state_for_client(serv, tossing);
@@ -276,7 +292,7 @@ static void define_phase_after_defense(struct server *serv)
             if(!is_receiving_cards_limit(&serv->cot, serv->turn_queue[0]->deck,
                                          &serv->cq) &&
                 check_someone_can_toss_card(serv->turn_queue,
-                                           serv->connected_players_counter,
+                                           serv->turn_queue_size,
                                            &serv->cq, &serv->cot))
             {
                 set_state_for_client(serv, tossing);
@@ -294,9 +310,8 @@ static void define_phase_after_defense(struct server *serv)
                 set_state_for_client(serv, defense);
                 set_whose_turn(serv, defense);
                 serv->state = defense_phase_out;
-            }
-                /* defender can't defense */
-#if 0
+
+            /* defender can't defense */
             } else {
                 serv->turn_queue[1]->defense_lost = 1;
                 put_all_cards_from_queue_to_table(&serv->cot, &serv->cq);
@@ -308,15 +323,10 @@ static void define_phase_after_defense(struct server *serv)
                     set_whose_turn(serv, tossing);
                     serv->state = tossing_phase_out;
                 } else {
-                    move_all_cards_to_defender(&serv->cot,
-                                               &serv->turn_queue[1]->deck);
-                    /* add shifting of turn arr*/
-                    set_state_for_client(serv, attack);
-                    set_whose_turn(serv, attack);
-                    serv->state = attack_phase_out;
+                    set_state_for_client(serv, display_only_table);
+                    serv->state = table;
                 }
             }
-#endif
         }
     }
 }
@@ -334,7 +344,7 @@ static void define_phase_after_tossing(struct server *serv)
             if(is_receiving_cards_limit(&serv->cot, serv->turn_queue[1]->deck,
                                         &serv->cq) &&
                     check_someone_can_toss_card(serv->turn_queue,
-                                           serv->connected_players_counter,
+                                           serv->turn_queue_size,
                                            &serv->cq, &serv->cot))
             {
                 set_state_for_client(serv, tossing);
@@ -364,7 +374,7 @@ static void define_phase_after_tossing(struct server *serv)
                                             serv->turn_queue[1]->deck,
                                             &serv->cq) &&
                         check_someone_can_toss_card(serv->turn_queue,
-                                            serv->connected_players_counter,
+                                            serv->turn_queue_size,
                                             &serv->cq, &serv->cot))
                 {
                     set_state_for_client(serv, tossing);
@@ -381,6 +391,9 @@ static void define_phase_after_tossing(struct server *serv)
 
 static void determine_server_state(struct server *serv)
 {
+    int key, turn_queue_resizing = 0;
+    struct session *defender = NULL;
+
     switch(serv->state) {
     case no_players:
         serv->state = first_player;
@@ -416,38 +429,129 @@ static void determine_server_state(struct server *serv)
         /* all answers received or the limit on card tossing was reached */
             define_phase_after_tossing(serv);
         set_record_status_for_all(serv);
-        update_card_quantity_arr(serv);
+        update_card_quantity_arr(serv->turn_queue, serv->cc);
         update_game_info(serv->gi, serv->connected_players_counter,
                          serv->shuffled_deck_size, serv->position_whose_turn);
         break;
     case table:
-        if(serv->turn_queue[1]->defense_lost) {
-            clear_defense_lost_status(serv->turn_queue[1]);
-            move_all_cards_to_defender(&serv->cot, &serv->turn_queue[1]->deck);
-            move_turn_queue_two_players_ahead(serv->turn_queue,
-                                              serv->connected_players_counter);
+        defender = serv->turn_queue[1];
+        key = serv->turn_queue[0]->player_position-1;
+        update_card_quantity_arr(serv->turn_queue, serv->cc);
+
+        /* ========= result of attacker's move ===========*/
+        /* attacker was left without cards */
+        if(!serv->shuffled_deck_size && !serv->cc.number_arr[key]) {
+            serv->turn_queue[0]->state = spectator;
+            /* resizing of turn_queue */
+            shift_turn_queue_by_one(serv->turn_queue, serv->turn_queue_size);
+            --serv->turn_queue_size;
+            turn_queue_resizing = 1;
         }
-        else {
+        /* ========= result of defender's move =========== */
+        if(defender->defense_lost) {
+            clear_defense_lost_status(defender);
+            move_all_cards_to_defender(&serv->cot, &defender->deck);
+            update_card_quantity_arr(serv->turn_queue, serv->cc);
+            if(!serv->shuffled_deck_size && serv->turn_queue_size == 1) {
+                serv->durak_position = defender->player_position;
+                set_state_for_client(serv, result);
+                serv->state = end_game;
+            } else {
+                turn_queue_resizing ? shift_turn_queue_by_one(serv->turn_queue,
+                                                        serv->turn_queue_size) :
+                            move_turn_queue_two_players_ahead(serv->turn_queue,
+                                                         serv->turn_queue_size);
+                set_whose_turn(serv, attack);
+                set_state_for_client(serv, attack);
+                serv->state = attack_phase_out;
+            }
+        } else {
             remove_cards_from_table(&serv->cot);
-            shift_turn_queue_by_one(serv->turn_queue,
-                                    serv->connected_players_counter);
+            key = defender->player_position - 1;
+            if(!serv->shuffled_deck_size && !serv->cc.number_arr[key]) {
+                /*
+                 * the final attack was completely beaten.
+                 * The defender also has no cards left
+                 */
+                if(serv->turn_queue_size == 1) {
+                    /* draw */
+                    serv->durak_position = 0;
+                    set_state_for_client(serv, result);
+                    serv->state = end_game;
+                } else {
+                    /* attacker has no cards in current part*/
+                    if(turn_queue_resizing) {
+                        shift_turn_queue_by_one(serv->turn_queue,
+                                                serv->turn_queue_size);
+                        --serv->turn_queue_size;
+                        defender->state = spectator;
+                        set_state_for_client(serv, attack);
+                        set_whose_turn(serv, attack);
+                        serv->state = attack_phase_out;
+                        /* third (last) player has cards */
+                        if(serv->turn_queue_size == 1) {
+                            serv->durak_position =
+                                        serv->turn_queue[0]->player_position;
+                            set_state_for_client(serv, result);
+                            serv->state = end_game;
+                        }
+                    } else {
+                        /* behind defender */
+                        move_turn_queue_two_players_ahead(serv->turn_queue,
+                                                         serv->turn_queue_size);
+                        --serv->turn_queue_size;
+                        defender->state = spectator;
+                        set_state_for_client(serv, attack);
+                        set_whose_turn(serv, attack);
+                        serv->state = attack_phase_out;
+                        if(serv->turn_queue_size == 1) {
+                            /* attacker is durak */
+                            serv->durak_position =
+                                serv->turn_queue[0]->player_position;
+                            set_state_for_client(serv, result);
+                            serv->state = end_game;
+                        }
+                    }
+                }
+            } else {
+                if(serv->turn_queue_size == 1) {
+                    serv->durak_position = defender->player_position;
+                    set_state_for_client(serv, result);
+                    serv->state = end_game;
+                } else {
+                    if(!turn_queue_resizing)
+                        shift_turn_queue_by_one(serv->turn_queue,
+                                                serv->turn_queue_size);
+                    set_state_for_client(serv, attack);
+                    set_whose_turn(serv, attack);
+                    serv->state = attack_phase_out;
+                }
+            }
         }
-        set_record_status_for_all(serv);
-        set_state_for_client(serv, attack);
-        set_whose_turn(serv, attack);
-        /*
-         * update the number of cards to determine how many cards
-         * a player still needs to add
-         */
-        update_card_quantity_arr(serv);
-        deal_cards(serv->shuffled_deck, &serv->shuffled_deck_size,
-                   serv->turn_queue, serv->connected_players_counter,
-                   serv->cc.number_arr);
-        /* update the card count after giving out */
-        update_card_quantity_arr(serv);
+        /* ======== dealing cards =========== */
+        if(serv->shuffled_deck_size) {
+            if(check_everyone_can_replanish_deck(serv->shuffled_deck_size,
+                                                 serv->turn_queue,
+                                                 serv->turn_queue_size,
+                                                 serv->cc.number_arr))
+            {
+                deal_cards(serv->shuffled_deck, &serv->shuffled_deck_size,
+                           serv->turn_queue, serv->turn_queue_size,
+                           serv->cc.number_arr);
+            } else
+                deal_one_card_in_turn(serv->shuffled_deck,
+                                      &serv->shuffled_deck_size,
+                                      serv->turn_queue, serv->turn_queue_size,
+                                      serv->cc);
+            /* update the card count after giving out cards */
+            update_card_quantity_arr(serv->turn_queue, serv->cc);
+        }
+
         update_game_info(serv->gi, serv->connected_players_counter,
                          serv->shuffled_deck_size, serv->position_whose_turn);
-        serv->state = attack_phase_out;
+        set_record_status_for_all(serv);
+        turn_queue_resizing = 0;
+        serv->tossing_limit = 0;
         break;
     case defense_phase_out:
         serv->state = defense_phase_in;
@@ -455,6 +559,9 @@ static void determine_server_state(struct server *serv)
     case tossing_phase_out:
         serv->state = tossing_phase_in;
         break;
+    case end_game:
+        close_connection(serv);
+        serv->state = no_players;
     }
     serv->change_server_state = 0;
 }
@@ -518,6 +625,7 @@ static void set_up_player_tracking(struct server *serv, fd_set *readfds,
         case table:
         case defense_phase_out:
         case tossing_phase_out:
+        case end_game:
             if(serv->sess_arr[i]->record) {
                 FD_SET(i, writefds);
                 *maxfd = i > *maxfd ? i : *maxfd;
@@ -549,8 +657,7 @@ static void set_up_player_tracking(struct server *serv, fd_set *readfds,
     }
 }
 
-static int check_server_state_change_conditions(int is_tossing_limit,
-                                                struct server *serv)
+static int check_server_state_change_conditions(struct server *serv)
 {
     switch(serv->state) {
     case start_game:
@@ -560,12 +667,13 @@ static int check_server_state_change_conditions(int is_tossing_limit,
     case defense_phase_in:
     case tossing_phase_out:
     case table:
+    case end_game:
         return 1;
     case tossing_phase_in:
-        if(is_tossing_limit ||
+        if(serv->tossing_limit ||
                 check_all_answers_were_received((const struct session**)
                                                  serv->turn_queue,
-                                             serv->connected_players_counter))
+                                                 serv->turn_queue_size))
             return 1;
     default:
         return 0;
@@ -573,14 +681,10 @@ static int check_server_state_change_conditions(int is_tossing_limit,
     return 0;
 }
 
-static void close_connection()
-{
-}
-
 static void make_data_transfer(struct server *serv, fd_set *readfds,
                                fd_set *writefds)
 {
-    int i, result, tossing_limit = 0;
+    int i, result;
     for(i = 0; i < serv->max_sess_arr_size; ++i) {
         if(!serv->sess_arr[i])
             continue;
@@ -610,7 +714,8 @@ static void make_data_transfer(struct server *serv, fd_set *readfds,
         case tossing_phase_out:
         case table:
             if(FD_ISSET(i, writefds) && serv->sess_arr[i]->record)
-                result = print_game_part(serv->sess_arr[i], serv->gi);
+                result = print_game_part(serv->sess_arr[i], serv->state,
+                                         serv->gi);
             serv->sess_arr[i]->record = 0;
             break;
         case attack_phase_in:
@@ -627,7 +732,7 @@ static void make_data_transfer(struct server *serv, fd_set *readfds,
         case tossing_phase_in:
             if(FD_ISSET(i, readfds)) {
                 /* to determine that the player can no longer tossing */
-                if(tossing_limit)
+                if(serv->tossing_limit)
                     serv->sess_arr[i]->tm = cancel;
                 result =
                     get_cards_from_tossing_player(serv->sess_arr[i],
@@ -637,22 +742,26 @@ static void make_data_transfer(struct server *serv, fd_set *readfds,
                     serv->sess_arr[i]->tm = answer_got;
 
                 if(result == 2)
-                    tossing_limit = 1;
+                    serv->tossing_limit = 1;
                 else if(result == 3)
                     serv->sess_arr[i]->tm = cancel;
             }
             break;
         case no_players:
             {}
+        case end_game:
+            if(FD_ISSET(i, writefds) && serv->sess_arr[i]->record)
+                print_game_result(serv->sess_arr[i], serv->durak_position);
+            break;
         }
     }
     if(serv->state == start_game || serv->state == table)
         sleep(2);
-    if(check_server_state_change_conditions(tossing_limit, serv))
+    if(check_server_state_change_conditions(serv))
         serv->change_server_state = 1;
     /* connection is closed */
     if(!result)
-        close_connection();
+        close_connection(serv);
 }
 
 int main_loop(struct server *serv)
diff --git a/server/server.h b/server/server.h
index 86e0fca..3578606 100644
--- a/server/server.h
+++ b/server/server.h
@@ -26,7 +26,8 @@ enum server_states {
     defense_phase_in,
     tossing_phase_out,
     tossing_phase_in,
-    table
+    table,
+    end_game
 };
 
 enum client_game_states {
@@ -39,7 +40,9 @@ enum client_game_states {
     defense,
     tossing,
     card_acceptance_status,
-    tossing_limit_status
+    tossing_limit_status,
+    spectator,
+    result
 };
 
 enum tossing_mode {
@@ -49,6 +52,13 @@ enum tossing_mode {
     none
 };
 
+enum spectator_mode {
+    spectator_attack,
+    spectator_defense,
+    spectator_tossing,
+    spectator_table
+};
+
 struct session {
     int fd;
     enum client_game_states state;
@@ -90,10 +100,16 @@ struct server {
     const char *trump_card;
     struct game_info *gi;
     struct session **turn_queue;
+    /* changes if the player has discarded all his cards
+     * (and shuffled_deck_size == 0)
+     */
+    int turn_queue_size;
     struct card_count cc;
     int position_whose_turn;
     struct card_queue cq;
     struct cards_on_table cot;
+    int durak_position;
+    int tossing_limit;
 };
 
 #endif
diff --git a/server/server_data_processing.c b/server/server_data_processing.c
index b7b2374..fc81996 100644
--- a/server/server_data_processing.c
+++ b/server/server_data_processing.c
@@ -63,7 +63,9 @@ int check_readiness(struct session *client)
 }
 /*
  * example: 10#\A^\7v'\n'
- * or       0'\n'
+ * or:      10#\A^\7v:
+ * or:      ='\n'
+ * or:      =:
  */
 static void copy_card_queue(int *offset, struct card_queue *cq)
 {
@@ -84,7 +86,7 @@ static void copy_card_queue(int *offset, struct card_queue *cq)
 
 /*
  * example: 10#+\+Q#+A^+\+-+7v:
- * or       0:
+ * or       =:
  */
 static void copy_cards_on_table(int *offset, struct cards_on_table cot)
 {
@@ -102,8 +104,8 @@ static void copy_cards_on_table(int *offset, struct cards_on_table cot)
 /*
  * example: 10#\A^\7v:
  * or       10#\A^\7v'\n'
- * or       0:
- * or       0'\n'
+ * or       =:
+ * or       ='\n'
  */
 static void copy_own_deck(int *offset, player_cards deck)
 {
@@ -153,8 +155,10 @@ static void copy_base_info(int *free_pos, struct game_info *gi,
         *free_pos += sprintf(output_buffer + *free_pos, "=:");
 }
 
-int print_game_part(const struct session *client, struct game_info *gi)
+int print_game_part(const struct session *client,
+                    enum server_states ss, struct game_info *gi)
 {
+    enum spectator_mode sp_mode;
     int free_pos;  /* free_pos == data length */
 
     copy_base_info(&free_pos, gi, client->state, client->deck,
@@ -181,6 +185,7 @@ int print_game_part(const struct session *client, struct game_info *gi)
         *(output_buffer + free_pos-1) = '\n';
         break;
     case defense_expectation:
+    case spectator:
         /* copying whose turn */
         free_pos += sprintf(output_buffer + free_pos, "%u:",
                             gi->position_whose_turn);
@@ -189,6 +194,17 @@ int print_game_part(const struct session *client, struct game_info *gi)
             free_pos += sprintf(output_buffer + free_pos, "=:");
         else
             copy_card_queue(&free_pos, gi->cq);
+        if(client->state == spectator) {
+            if(ss == attack_phase_out)
+                sp_mode = spectator_attack;
+            else if(ss == defense_phase_out)
+                sp_mode = spectator_defense;
+            else if(ss == tossing_phase_out)
+                sp_mode = spectator_tossing;
+            else
+                sp_mode = spectator_table;
+            free_pos += sprintf(output_buffer + free_pos, "%u:", sp_mode);
+        }
         *(output_buffer + free_pos-1) = '\n';
     default:
         {}
@@ -315,6 +331,10 @@ int get_cards_from_tossing_player(struct session *client,
     if(!read_result)
         return read_result;
 
+    /* cancellation */
+    if(client->buffer[0] == '\n')
+        return 3;
+
     for(i = 0, j = 0; i < read_result; ++i) {
         if(client->buffer[i] == '\\') {
             /* tossing limit was set */
@@ -342,9 +362,6 @@ int get_cards_from_tossing_player(struct session *client,
         given_card[j] = client->buffer[i];
         ++j;
     }
-    /* cancellation */
-    if(client->buffer[0] == '\n')
-        return 3;
 
     /* 7 -- state for result of received cards */
     data_length = sprintf(output_buffer, "%d:%s\n", card_acceptance_status,
@@ -355,3 +372,12 @@ int get_cards_from_tossing_player(struct session *client,
     else
         return 2;
 }
+
+void print_game_result(const struct session *client, int durak_position)
+{
+    int data_size;
+
+    data_size =
+        sprintf(output_buffer, "%u:%u\n", client->state, durak_position);
+    write_to_client(client->fd, data_size);
+}
diff --git a/server/server_data_processing.h b/server/server_data_processing.h
index 875fd98..e6c1ab0 100644
--- a/server/server_data_processing.h
+++ b/server/server_data_processing.h
@@ -6,7 +6,9 @@
 int print_message_for_first_player(int fd);
 int print_connected_players(int fd, int number);
 int check_readiness(struct session *client);
-int print_game_part(const struct session *client, struct game_info *gi);
+                                                /* for define spectator mode */
+int print_game_part(const struct session *client, enum server_states ss,
+                    struct game_info *gi);
 int get_cards_from_attacker(struct session *client,
                             const struct cards_on_table *cot,
                             const player_cards defense_deck,
@@ -17,5 +19,6 @@ int get_cards_from_tossing_player(struct session *client,
                                   const player_cards defense_deck,
                                   struct cards_on_table *cot,
                                   struct card_queue *cq);
+void print_game_result(const struct session *client, int durak_position);
 
 #endif
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
diff --git a/server/server_game_process.h b/server/server_game_process.h
index 9338c25..f384fdc 100644
--- a/server/server_game_process.h
+++ b/server/server_game_process.h
@@ -23,16 +23,21 @@ const char** get_shuffled_deck();
 void deal_first_cards(const char **shuffled_deck, int *cards_left,
                       player_cards *deck);
 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);
+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);
 const char* extract_trump_card(const char **shuffled_deck, int *cards_left);
 #if 0
 const char* find_trump_suit(const char **shuffled_deck, int *cards_left);
 #endif
 int find_lowest_trump(player_cards deck, const char *trump);
-void shift_turn_queue_by_one(struct session **turn_queue, int size);
-void move_turn_queue_two_players_ahead(struct session **turn_queue, int size);
-void update_card_quantity_arr(struct server *serv);
+void shift_turn_queue_by_one(struct session **turn_queue, int turn_queue_size);
+void move_turn_queue_two_players_ahead(struct session **turn_queue,
+                                       int turn_queue_size);
+void update_card_quantity_arr(struct session **turn_queue,
+                              struct card_count cc);
 
 struct game_info* get_new_game_info(int players_number, int *card_quantity_arr,
                                     int shuffled_cards_left,
@@ -71,10 +76,15 @@ void remove_cards_from_table(struct cards_on_table *cot);
 int calculate_defense_card_quantity_on_table(const struct cards_on_table *cot);
 int calculate_attack_card_quantity_on_table(const struct cards_on_table *cot);
 int check_all_answers_were_received(const struct session **turn_queue,
-                                    int size);
+                                    int turn_queue_size);
 int is_receiving_cards_limit(const struct cards_on_table *cot,
                              player_cards defense_deck,
                              const struct card_queue *cq);
 void clear_defense_lost_status(struct session *defender);
+int check_everyone_can_replanish_deck(int shuffled_cards_left,
+                                 struct session **turn_queue,
+                                 int turn_queue_size, int *number_arr);
+void find_out_who_dropped_all_cards(struct session **turn_queue,
+                                    int turn_queue_size, int *number_arr);
 
 #endif