c - game

//
// Created by edens on 21/09/2022.
//

#ifndef EMBEDDED_C_FINAL_PROJECT_BLACK_JACK_GAME__V1_4_0_CARDLIST_H
#define EMBEDDED_C_FINAL_PROJECT_BLACK_JACK_GAME__V1_4_0_CARDLIST_H

#include "Card.h"



typedef struct cardlist{
    card_t *head;
    size_t len; // cache
}cardlist_t;


void init_card_deck(cardlist_t* deck);

card_t *get_random_card_from_deck(cardlist_t* deck);

void delete_data_node(card_t*);

void push_card_to_list(cardlist_t*,card_t *);

void print_player_deck(cardlist_t *);

void free_init(cardlist_t *);

void print_list(cardlist_t *);

#endif //EMBEDDED_C_FINAL_PROJECT_BLACK_JACK_GAME__V1_4_0_CARDLIST_H


//
// Created by edens on 21/09/2022.
//

#ifndef EMBEDDED_C_FINAL_PROJECT_BLACK_JACK_GAME__V1_4_0_CARD_H
#define EMBEDDED_C_FINAL_PROJECT_BLACK_JACK_GAME__V1_4_0_CARD_H

#include <stdint.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#define  SUITS 4

#define  RANKS 13

typedef struct card{
    uint8_t data;
    struct card* next;
}card_t;

uint8_t Card_get_rank(card_t* card);

uint8_t Card_get_suit(card_t* card);

void Card_set_rank(card_t* card, uint8_t rank);

void Card_set_suit(card_t* card, uint8_t suit);



#endif //EMBEDDED_C_FINAL_PROJECT_BLACK_JACK_GAME__V1_4_0_CARD_H


//
// Created by edens on 21/09/2022.
//
#include "CardList.h"
#include <stdlib.h>
const char *suits[SUITS] ={"Spades","Hearts","Clubs","Diamonds"};

const char *ranks[RANKS+1]={"None","Ace","2","3","4",
                              "5","6","7","8",
                              "9","10","Jack","Queen","King"};

void init_card_deck(cardlist_t *deck)
{
    card_t *last_node = NULL;
    card_t *new_node = NULL;
   for (uint8_t suit = 0; suit < SUITS; suit++) {
       for (uint8_t rank = 1; rank < RANKS + 1; rank++) {
           new_node = (card_t *) calloc(1, sizeof(*new_node));
           if (new_node == NULL) {
               perror("dynamic allocation error\n");
               return;
           }
           Card_set_rank(new_node, rank);
           Card_set_suit(new_node, suit);

           if (deck->head == NULL) {
               deck->head = new_node;
           } else {
               last_node->next = new_node;
           }
           deck->len++;
           last_node = new_node;
       }
    }
}

card_t *get_random_card_from_deck(cardlist_t* list) {
    int index = rand() % list -> len; //52 // if rand 0 its dead
    card_t* tmp = NULL;
    if (index==0)
    {
        tmp = list -> head;
        list->head = list->head->next;
    } else {
        tmp = list->head;
        // arrive to item before requested
        while (index != 1) {
            tmp = tmp->next;
            index--;
        }
        card_t *result = tmp->next;
        tmp->next = result->next;
        tmp = result;
    }
    list -> len--;
    tmp -> next = NULL;
    return tmp;
}

void delete_data_node(card_t* ptr)
{
    card_t *tmp = ptr;
    tmp=tmp->next;
    ptr->data=tmp->data;
    ptr->next=tmp->next;
    free(tmp);
}

void push_card_to_list(cardlist_t* list,card_t *data) {
    if (list->head==NULL) // case when its empty
    {
        list->head=data;
    } else {
        card_t *ptr = list->head;
        while (ptr->next != NULL) // case when not empty
        {
            ptr=ptr->next;
        }
        ptr->next=data;
    }
    data->next=NULL;
    list->len++;
}

void print_player_deck(cardlist_t *list)
{
    printf("your Hand: \n");
    card_t *ptr = list->head;
    while(ptr)
    {
        printf("     %s of %s\n", ranks[Card_get_rank(ptr)], suits[Card_get_suit(ptr)]);
        printf("---------------\n");
        printf(" Location Debug %d\n\n", ptr->data);
        ptr=ptr->next;
    }
}

void print_list(cardlist_t *list)
{
    card_t *ptr = list -> head;
    while (ptr)
    {
        printf("%d -> ",ptr->data);
        ptr = ptr->next;
    }
    printf("NULL \n");
}

void free_init(cardlist_t *list)
{
    card_t *head = list -> head;
    while(head)
    {
        card_t *tmp = head;
        head=head->next;
        free(tmp);
    }
    list -> head = NULL;
}

//
// Created by edens on 21/09/2022.
//
#include "Card.h"
#include <stdlib.h>
#include <stdio.h>


uint8_t Card_get_rank(card_t* card) {
    return ((card -> data) & (15 /*binary 1111*/ << 2)) >> 2;
}

uint8_t Card_get_suit(card_t* card) {
    return (card -> data) & 3 /*binary 11*/;
}

void Card_set_rank(card_t* card, uint8_t rank) {
    (card -> data) = (card -> data) | (rank << 2);
}

void Card_set_suit(card_t* card, uint8_t suit) {
    (card -> data) = (card -> data) | suit;
}

#include "CardList.h"
#include "time.h"
int main(int argc,char** argv)
{
    srand(time(NULL));
    unsigned int amount=0;
    int cash=1000;
    int pot=0;
    unsigned int player_sum;
    unsigned int dealer_sum;
    int player_choice=0;
    cardlist_t deck = {
            .head = NULL,
            .len = 0,
    };

    cardlist_t dealer_hand= {
            .head = NULL,
            .len = 0,
    };

    cardlist_t player_hand= {
            .head = NULL,
            .len = 0,
    };

    init_card_deck(&deck);
    print_list(&deck);
    printf("Embedded C Final Project Black-Jack Game (v1.4.0)\n");
    printf(" \t Created By : Eden Sheiko\n");

    while (1) {
        printf("+++++++++++++++++++++++++++++++++++++++++++++++++\n");
        printf("\t \t New Game \n");
        printf("+++++++++++++++++++++++++++++++++++++++++++++++++\n");

        printf("How much would you like to bet? \n");
        printf("Enter a number in multiples of 10: \n");
        fflush(stdout);

        scanf("%d",&amount);
        while (getchar() != '\n');
        if (amount % 10 == 0 )
        {
            card_t *random_card_p_1=get_random_card_from_deck(&deck);
            card_t *random_card_p_2=get_random_card_from_deck(&deck);
            card_t *random_card_d_1=get_random_card_from_deck(&deck);
            card_t *random_card_d_2=get_random_card_from_deck(&deck);

            push_card_to_list(&player_hand,random_card_p_1);
            push_card_to_list(&player_hand,random_card_p_2);
            push_card_to_list(&dealer_hand,random_card_d_1);
            push_card_to_list(&dealer_hand,random_card_d_2);
            print_player_deck(&player_hand);

            printf("would you like to continue? press 0 for yes or anything else for no\n");
            scanf("%d",&player_choice);
            while (getchar() != '\n');
            fflush(stdout);
            if(player_choice!=0)
            {
                break;
            }
            if (player_hand.len>0 && dealer_hand.len>0)
            {
                free_init(&dealer_hand);
                free_init(&player_hand);
            }
        }
        else
        {
            printf("Error , please Enter a number in multiples of 10:\n");
        }
    }
    free_init(&deck);
    return 0;
}