Prefinal version

Added client.
Moved files to directories.

1 files changed, 193 insertions, 0 deletions

diff --git a/client/card_stack.c b/client/card_stack.c
new file mode 100644
index 0000000..5d0700b
--- /dev/null
+++ b/client/card_stack.c
@@ -0,0 +1,193 @@
+#include "card_stack.h"
+#include "card_handling.h"
+#include "client.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+void init_stack(player_cards *deck)
+{
+    *deck = NULL;
+}
+
+void push_stack(player_cards *deck, char *str)
+{
+    struct card_stack_item *tmp = malloc(sizeof(struct card_stack_item));
+    tmp->str = str;
+    tmp->tip = ' ';
+    tmp->is_usable = 0;
+    tmp->next = *deck;
+    *deck = tmp;
+}
+
+void clear_stack(player_cards *deck)
+{
+    struct card_stack_item *tmp;
+
+    while(*deck) {
+        tmp = *deck;
+        *deck = tmp->next;
+        if(tmp->str)
+            free(tmp->str);
+        free(tmp);
+    }
+}
+
+int is_empty_stack(player_cards deck)
+{
+    return deck == NULL;
+}
+
+#if 0
+static int convert_rank_to_int(const char *card)
+{
+    int length;
+    char str_rank[2];
+
+    length = strlen(card);
+    /* 10 - the only one of its kind */
+    if(length == 3)
+        return 10;
+
+    str_rank[0] = card[0];
+    str_rank[1] = '\0';
+
+    switch(card[0]) {
+    case 'J':
+        return 11;
+    case 'Q':
+        return 12;
+    case 'K':
+        return 13;
+    case 'A':
+        return 14;
+    default:
+        return strtol(str_rank, NULL, 10);
+    }
+    return 0;
+}
+#endif
+
+void add_hint_letters_stack(player_cards deck)
+{
+    unsigned char letter = 'a';
+
+    while(deck) {
+        deck->tip = letter;
+        ++letter;
+        if(letter > 'z')
+            letter = 'A';
+        deck = deck->next;
+    }
+}
+
+void mark_card_for_attackers_stack(player_cards deck)
+{
+    char *card = NULL, *found_card;
+    struct card_stack_item *search_deck = NULL;
+    int target_rank, found_rank;
+
+    while(deck) {
+        /* is the card already marked? */
+        if(deck->is_usable) {
+            deck = deck->next;
+            continue;
+        }
+        card = deck->str;
+        target_rank = convert_rank_to_int(card);
+        search_deck = deck->next;
+        while(search_deck) {
+            if(search_deck->is_usable) {
+                search_deck = search_deck->next;
+                continue;
+            }
+            found_card = search_deck->str;
+            found_rank = convert_rank_to_int(found_card);
+            if(found_rank == target_rank)
+                search_deck->is_usable = 1;
+            search_deck = search_deck->next;
+        }
+        deck = deck->next;
+    }
+}
+#if 0
+static int is_card_beaten(const char *attack_card, const char *defend_card,
+                          const char *trump_suit)
+{
+    int length, attack_rank, defend_rank;
+    const char *attack_suit, *defend_suit;
+
+    length = strlen(attack_card);
+    attack_suit= attack_card + length - 1;
+    length = strlen(defend_card);
+    defend_suit = defend_card + length - 1;
+
+    /* suits matched */
+    if(!strcmp(attack_suit, defend_suit)) {
+        attack_rank = convert_rank_to_int(attack_card);
+        defend_rank = convert_rank_to_int(defend_card);
+        if(defend_rank > attack_rank)
+            return 1;
+        /* defender has a trump suit */
+    } else if(!strcmp(defend_suit, trump_suit))
+        return 1;
+    return 0;
+}
+#endif
+
+void mark_card_for_defenders_stack(player_cards deck,
+                                   struct cards_on_table *cot, char *trump_suit)
+{
+    int i;
+
+    while(deck) {
+        for(i = 0; i <= cot->card_arr_idx; ++i)
+            if((i == 0 || !(i % 3)) && is_card_beaten(cot->card_arr[i],
+                                                      deck->str, trump_suit))
+            {
+                deck->is_usable = 1;
+                break;
+            }
+        deck = deck->next;
+    }
+}
+#if 0
+static int check_matched_ranks(const char *attack_card,
+                               const char *not_defender_card)
+{
+    int attack_rank, not_defender_rank;
+
+    attack_rank = convert_rank_to_int(attack_card);
+    not_defender_rank = convert_rank_to_int(not_defender_card);
+    return attack_rank == not_defender_rank;
+}
+#endif
+
+void mark_card_for_tossing_stack(player_cards deck, struct cards_on_table *cot)
+{
+    int i;
+
+    while(deck) {
+        for(i = 0; i <= cot->card_arr_idx; ++i) {
+            if(cot->card_arr[i][0] == '-' || cot->card_arr[i][0] == '\\')
+                continue;
+            if(check_matched_ranks(cot->card_arr[i], deck->str)) {
+                deck->is_usable = 1;
+                break;
+            }
+        }
+        deck = deck->next;
+    }
+}
+
+int card_search_by_letter(player_cards deck, int letter)
+{
+    while(deck) {
+        if(deck->tip == letter && deck->is_usable) {
+            deck->is_usable = 0;
+            return 1;
+        }
+        deck = deck->next;
+    }
+    return 0;
+}