PokerGame.c

//  Andrew Geltz
//  COP3223
//  Assignment 5

//  This program generates two poker hands and tells which one wins.
//  I took a structural approach because it made things much cleaner
//  and more logical to access.

//  Include standard libraries and time for random
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//  Cards are made of simply a suit and a value
struct Card{
    int face;
    int suit;
};

//  Each hand is just a set of five cards
struct Hand{
    struct Card cards[5];
};

//  The deck is only going to hold the cards we have already generated.
//  It also has to know how many cards have been dealt so we don't
//  have to iterate through a bunch of blank card objects.
struct Deck{
    struct Card dealtCards[52];
    int numCardsDealt;
};

//  I am making these variables global so that we don't have to deal with
//  managing pointers to local objects.
struct Hand hand1, hand2;
struct Deck deck;

//  These array will hold all of the strings to make printing simple.
static const char *faceStrings[] = {
    "Two","Three","Four","Five","Six","Seven","Eight","Nine",
    "Ten","Jack","Queen","King","Ace"};
static const char *suitStrings[] = {
    "Hearts","Clubs","Diamonds","Spades"};
static const char *rankStrings[] = {
    "High Card","Single Pair","Two Pair","Three of a Kind","Straight",
    "Flush","Full House","Four of a Kind","Straight Flush"};

//  We need functions for generating hands, printing hands and determining
//  which hand won.
void generateHands();
struct Card dealCard();// Look at the generateHands() for more on this
void printHands();
void analyzeHands();

int main(){
    //  First thing, we need to initialize our deck
    deck.numCardsDealt=0;

    //  Seed our random generator
    srand(time(NULL));

    //  Then generate cards
    generateHands();

    //  Print them
    printHands();

    //  And find the winner
    analyzeHands();

    //  Let the program know were done and no problems
    return 0;
}

void generateHands(){
    int i;// Counter variable

    //  We are going to do both hands in one loop to make the code simpler.
    //  This would be like the dealer alternating giving cards to one
    //  player or the other.
    for(i=0; i<5; i++){
        hand1.cards[i] = dealCard();
        hand2.cards[i] = dealCard();
    }
}

struct Card dealCard(){
    int i;// Counter variable
    int isUnique;// This variable keeps track if there are other matching cards
    struct Card cardToDeal;// Card we will return
    while(1){// Infinite loop, we will brake out when we get the card
        cardToDeal.face = rand()%13;
        cardToDeal.suit = rand()%4;
        isUnique = 1;
        // We only need to check from 0 to the last card we dealt
        for(i=0; i<deck.numCardsDealt; i++){
            if(deck.dealtCards[i].face == cardToDeal.face && deck.dealtCards[i].suit == cardToDeal.suit)
                isUnique = 0;
        }
        // If cardToDeal hasn't been dealt
        if(isUnique){
            deck.numCardsDealt++;
            deck.dealtCards[deck.numCardsDealt] = cardToDeal;
            return cardToDeal;
        }
    }
}

//  The print statement are a little weird here so I will try and explain.
//  The string arrays I declared around line 40 correspond to the indexes
//  of the cards face or suit value. We are essentially getting the string that
//  is at the index of our face or suit.
void printHands(){
    int i;// Counter variable
    printf("Player one has:\n");
    for(i=0; i<5; i++)
        printf("%s of %s\n", faceStrings[hand1.cards[i].face], suitStrings[hand1.cards[i].suit]);
    printf("\nPlayer two has:\n");
    for(i=0; i<5; i++)
        printf("%s of %s\n", faceStrings[hand2.cards[i].face], suitStrings[hand2.cards[i].suit]);
}

void analyzeHands(){
    int i,j;// Counter variable
    // I am going to try and use a system similar to the one in the document
    // We need counts of each face and suit so lets make those first
    int hand1FaceCounts[13];
    int hand1SuitCounts[4];
    int hand2FaceCounts[13];
    int hand2SuitCounts[4];

    // We have to initialize these array to zero. You can iterate but
    // I am going to use the memset function. If you don't know what that
    // means, just iterate through them.
    memset(hand1FaceCounts,0,sizeof(hand1FaceCounts));
    memset(hand1SuitCounts,0,sizeof(hand1SuitCounts));
    memset(hand2FaceCounts,0,sizeof(hand2FaceCounts));
    memset(hand2SuitCounts,0,sizeof(hand2SuitCounts));

    // Now lets go ahead an get those numbers
    for(i=0; i<5; i++){
        hand1FaceCounts[hand1.cards[i].face]++;
        hand1SuitCounts[hand1.cards[i].suit]++;
        hand2FaceCounts[hand2.cards[i].face]++;
        hand2SuitCounts[hand2.cards[i].suit]++;
    }

    // Now we need a bunch of variables to keep track of what each hand has.
    // I am going to abbreviate hand1 into h1 and so on.
    int h1Rank=0, h1Consec=0, h1Straight=0, h1Flush=0, h1Four=0, h1Three=0, h1Pairs=0;
    int h2Rank=0, h2Consec=0, h2Straight=0, h2Flush=0, h2Four=0, h2Three=0, h2Pairs=0;

    // The following chunk of code was taken from the assignment sheet.
    // I adapted it to check both hands.
    // check for flush – 5 cards of the same suit
	for(i=0; i<5; i++){
        if(hand1SuitCounts[i]==5)
            h1Flush=1;
        if(hand2SuitCounts[i]==5)
            h2Flush=1;
	}

	// check for straight – eg. One each of 5,6,7,8,9
	//    locate the first card
	i = 0;
	while (hand1FaceCounts[i] == 0)
		i++;
	//     count the consecutive non-zero faces
	for (; i < 3 && hand1FaceCounts[i]; i++)
		h1Consec++;
	if (h1Consec == 5)
		h1Straight = 1;

    // check for straight – eg. One each of 5,6,7,8,9
	//    locate the first card
	i = 0;
	while (hand2FaceCounts[i] == 0)
		i++;
	//     count the consecutive non-zero faces
	for (; i < 3 && hand2FaceCounts[i]; i++)
		h2Consec++;
	if (h2Consec == 5)
		h2Straight = 1;

	/* check for 4-of-a-kind, 3-of-a-kind, and pairs */
	for (i = 0; i < 14; i++) {
		if (hand1FaceCounts[i] == 4)
			h1Four = 1;
		if (hand1FaceCounts[i] == 3)
			h1Three = 1;
		if (hand1FaceCounts[i] == 2)
			h1Pairs++;
	}
	for (i = 0; i < 14; i++) {
		if (hand2FaceCounts[i] == 4)
			h2Four = 1;
		if (hand2FaceCounts[i] == 3)
			h2Three = 1;
		if (hand2FaceCounts[i] == 2)
			h2Pairs++;
	}

	// Hand 1 ranking
	if (h1Straight && h1Flush)
		h1Rank=8;
	else if (h1Four)
		h1Rank=7;
	else if (h1Three && h1Pairs == 1)
		h1Rank=6;
	else if (h1Flush)
		h1Rank=5;
	else if (h1Straight)
		h1Rank=4;
	else if (h1Three)
		h1Rank=3;
	else if (h1Pairs == 2)
		h1Rank=2;
	else if (h1Pairs == 1)
		h1Rank=1;
	else
		h1Rank=0;

    // Hand 2 ranking
    if (h2Straight && h2Flush)
		h2Rank=8;
	else if (h2Four)
		h2Rank=7;
	else if (h2Three && h2Pairs == 1)
		h2Rank=6;
	else if (h2Flush)
		h2Rank=5;
	else if (h2Straight)
		h2Rank=4;
	else if (h2Three)
		h2Rank=3;
	else if (h2Pairs == 2)
		h2Rank=2;
	else if (h2Pairs == 1)
		h2Rank=1;
	else
		h2Rank=0;

    // Print what each player has
    printf("\nPlayer one has a %s.\n",rankStrings[h1Rank]);
    printf("Player two has a %s.\n",rankStrings[h2Rank]);

    // Determine winner
    // This is where you would expand if you wanted to handle tie breaking
    if(h1Rank>h2Rank)
        printf("That means that player one wins!!!\n");
    else if(h2Rank>h1Rank)
        printf("That means that player two wins!!!\n");
    else
        printf("That means that the two players tie!!!\n");
}

Thanks for posting; very useful! I know that there are different strategies and so on which can help you to win, but I've never used anything. I play for fun, and I always rely on myself. Of course, I'd like to win, but my main goal is to have a good time. Some time ago, I found this site https://zodiac-casinos.at/ and since then, I've been playing there. All the games are cool, but I still haven't tried them all. But I have a good time, and it's the most important thing for me.

Hey guys! Nothing beats that rush when the plane starts climbing and you can feel the stakes ticking up with every second. I remember stumbling onto https://mostbet-aviator.com.in/ while scrolling late at night, half-bored and half-curious, and suddenly I was hooked on the tension of deciding when to cash out. It’s wild how a simple timing decision can feel like life or death for your bets, and the adrenaline keeps you on edge even after hours of playing. I started experimenting with smaller bets first, just to get the hang of the multipliers and the way the flight patterns shift unpredictably, and it seriously helped me avoid dumb mistakes early on. Watching the plane soar, pulling out too soon or too late, it’s a mix of strategy and instinct, and you learn to trust your gut faster than you expect. If you’re diving in, don’t ignore the practice mode—it’s more than just a demo; it’s a lab for building confidence before you go big.