1. Deadline: 
Tuesday 14th May 2024 
(Feedback to be released on 4
the June 2024) 
2. Weighting: 
50% 
3. Overview 
Create a basic GUI card game using C++ with Qt and organise the game structure using OOP 
methods. 
Royalty-free card images will be available for you to download from the COMP282 Canvas page for 
you to use in the application if you choose. These will consist of 52 PNG images of standard playing 
cards. 
 
Our game is based loosely on the hands of the classic card game, Poker. We will define the rules of 
the game as follows: 
1. Objective: The objective of the game is to beat a computer opponent with combinations of 5 
cards (known as a Hand) worth the highest value. 
2. Card Value: 
a. Cards have a value of 1 to 14 and a suit chosen from Hearts (♥), Diamonds (♦), 
Spades (♠) and Clubs (♣). There are 52 cards in a Deck consisting of 13 cards in 
each suit. There are no other cards (such as Jokers) needed in the game, and only one 
deck is used. 
b. Value ranges from 1 (low Ace) through the numbered cards worth 2 – 10 then 11 
(Jack), 12 (Queen), 13 (King) and 14 (high Ace). Note that the Ace can be chosen to 
be worth 1 or 14 as desired to match with other held cards, this is useful for straight 
hands. 
c. The value of cards is used to determine the winner when hands have the same rank 
(more on ranks and categories later), e.g. both players have One Pair. If the value of 
the rank cards are the same, the values of the remaining cards are used, e.g.: 
Player has a pair of 10s, Computer has a pair of 7s, so Player wins. 
In this case both players have One Pair of the same value (10). So we determine the value of the remaining cards, which are 10 for Player (2+3+5) and 19 for Computer 
(9+6+4), so Computer wins. 
d. The suit is only used when determining a Flush (all cards the same suit). 
e. No suit has a higher value than another. E.g. a Flush of hearts and a flush of clubs 
with the same numerical cards are worth the same. 
3. The rank and name of the combinations are as follows, with the highest values being 
statistically less likely to occur and which automatically beats any card combination from a 
lower category. E.g. any Straight Flush beats any Four-of-a-Kind: 
Rank 
(1=highest) 
Category Example Hand Explanation 
1 Straight 
Flush 
 
Flush and 
Straight at the 
same time. 
 
2 Four Of A 
Kind 
 
Four cards 
with the same 
value – in this 
example four 
cards of value 
5. 
3 Full House 
 
Three of one 
the same value 
and two of 
another. 
4 Flush 
 
All cards are 
the same suit – 
in this example 
all Diamonds. 
The value and 
order of the 
cards does not 
matter 
5 Straight 
 
All cards are in 
numerical 
order, suit 
doesn’t matter. 
6 Three Of A 
Kind 
 
Three cards 
with the same 
value – in this 
example 
Queens. 
7 Two Pair 
 
Two separate 
matched pairs 
of different 
values, in the 
example above two Jacks and 
two 3s 
8 One Pair 
 
A single 
matched pair 
of the same 
value, in the 
example above 
a pair of 10s. 
9 Highest 
Card 
 
All cards are 
different for 
both players 
and there is not 
a straight or 
flush 
 
4. If both players have a Straight Flush the one with the highest card wins, otherwise it is a 
draw. 
5. If both players have Four-of-a-Kind the higher card wins, e.g. four 8s would beat four 5s. It 
is not possible for both players to have the same 4 cards so the winner can always be found by 
comparing these. 
6. If both players have Full House the higher card of the group of three wins, e.g. three 4s and 
two Queens would beat three 2s and two kings. It is not possible for both players to have three 
cards of the same value so the winner can always be found by comparing these. 
7. If both players have a Flush the highest card wins, in this example a Jack. If both players 
have a flush and the same highest cards the next highest are compared, e.g. K, 10, 8, 7, 5 
would beat K, 10, 8, 7, 3. If the cards are still same the same, e.g. both players have 10, 8, 5, 
4 and 2 in different suits it’s a draw. 
8. Examples of Straights are A-5, 2-6, 3-7, 4-8, 5-9, 6-10 (as example), 7-J, 8-Q, 9-K, 10-A. 
Note that the Ace can be worth both 1 or 14 giving two possible straights that include it, e.g. 
(A, 2, 3, 4, 5) or (10, J, Q, K, A). In all other situations the Ace is always worth 14. If both 
players get a Straight the highest card of each wins, e.g. 9-Q would beat 3-7. If the high card 
of both straight is the same, it’s a draw. 
9. If both players have Three-of-a-Kind the higher card wins, e.g. three Jacks would beat three 
8s. It is not possible for both players to have three cards of the same value so the winner can 
always be found by comparing these. 
10. If both players have Two Pair the highest pair wins, e.g. a pair of queens and a pair of 3s 
beats a pair of 10s and a pair of 9s. If both pairs are the same for each player the highest fifth 
card determines the winner, e.g. J, J, 8, 8, A beats J, J, 8, 8, 10 with deciding Ace being worth 
14 not 1. A draw is possible. 
11. If both players have One Pair the highest pair wins, e.g. a pair of 7s beats a pair of 2s. If the 
pair is the same for each player the highest of the remaining three cards determines the 
winner. A draw is possible. 
12. The High Card result is determined by the highest card and continues until the last card. E.g. 
Q, 8, 5, 4, 3 beats Q, 8, 5, 4, 2. A draw is possible. 
 
 5. Basic Gameplay (45 marks) 
1. There should be a ‘start’ (or ‘deal’) button on the game window. When this button is clicked, 
the game starts. 
2. The cards are shuffled before each game. 
3. For each Round, 10 cards taken from the shuffled Deck and distributed to the Player and the 
Computer, making two hands with 5 cards each. 
4. When a card has been used in a hand, it cannot be used again during that game (but bear in 
mind the ‘advanced gameplay’ sections below). 
5. Each game consists of rounds. When a new round is started but there are less than 10 cards 
left in the deck, the game ends (since we cannot deal full hands to the players). 
6. At the start of each round, the game window should display a representation of the player’s 
hand (5 cards) and the computer’s hand (5 cards). This can be text-based, but you will get 
marks for using images. Under each card, it should say the name of the card (e.g. ‘6 of 
Spades’ or ‘6♠’). 
7. The game should work out the categories (and therefore the rank) of each of the hands. Above 
the cards, there should be a label that displays the category of the hand (e.g. ‘Full House’). 
8. Based on those ranks, the game should determine who has the strongest hand. This should 
also be displayed. 
9. There should be a button marked ‘Next Round’ which will move the game on to the next 
round. If there are no more rounds, the button should be marked ‘Finish Game’. 
10. A score should be displayed and updated at the start of each round, that shows the player’s 
score and the computer’s score. The scores represent the number of hands won in the game. 
11. After the 5 rounds have been played, the winner should be announced (or a draw declared if 
applicable), and the player should be able to play another game if they wish to. 
6. Advanced gameplay (10 marks) 
In rounds 1-4, allow the player to swap up to three cards from their hand with cards from the deck. 
It’s up to you how to implement the interface for this (perhaps ‘Swap’ buttons, or perhaps by clicking 
the card, or another method of your choosing). Don’t allow swapping in Round 5 (because in Round 5 
there will be only 2 cards left in the deck). The cards that are swapped out of the player’s hand can 
still remain in the game (i.e. they are replaced in the Deck at a random location). 
7. Even more advanced gameplay (10 marks) 
If the player swaps a card, the computer has the opportunity to swap a card from its deck too. The 
computer will have to determine whether or not it is advantageous to swap a card (if the computer has 
a Straight Flush hand, it won’t be worth swapping, for example, but if it has 1 pair it may want to 
swap one of the other cards to attempt to improve the hand). 
This can be as basic or complex as you like. A basic version may just scan a hand for groups of two, 
three or four cards of the same value and swap any remaining cards to try to improve this. A more 
advanced system may calculate the probabilities of getting a straight or flush hand. 
6. Suggested Classes/Objects and Methods in the game 
 
You are free to code the game as you like. But please ensure that you have classes called: 
 Game, Player, Card, Deck, Hand. 
 
There are some suggested structures and methods below which you may find helpful. Game class: Consists of two Players. Once the game has been completed the winner (or a draw) is 
declared. Game state is shown in a game window as text and/or graphics of cards held with buttons 
for triggering methods. 
Player class: A class representing a player with a name and a score of hands won. Each Player 
has a Hand of five Cards. Assume that both players can see each other’s cards and the result is 
based purely on getting a strong hand of cards. 
Card class: Has a value and a suit (e.g. 7 of Hearts). 
Methods: 
Card::getValue() returns the value as an integer, (e.g. 7). Aces are always worth 14 except 
when used as start of a straight. 
Card::getSuit() returns the suit name as a QString, e.g. “Clubs”, “Diamonds”, “Hearts” or 
“Spades”. 
Card::getName() returns the card name as a QString, e.g. “Jack of Clubs”, “Two of Hearts”. 
Card::getNumber() returns the card type as an integer (see the section on Hand::setHand 
method to see how the system works). E.g. 9 of Diamonds would return 209. 
 
Deck class: Consists of a complete standard pack of 52 cards with one of each value 2-10 and Jack, 
Queen, King and Ace in each suit (4 * 13 cards). 
 
Methods: 
Deck::createDeck() generates a complete pack correctly as stated above in any order. Each 
card is a Card object. 
 
Deck::shuffle() randomly puts the cards in a random order, e.g. before a game begins or after 
the last card is dealt. 
 
Deck::dealCard() returns the first card in deck and continues until the entire deck has been 
dealt. When the last card has been dealt the entire deck is automatically shuffled so dealing can 
continue indefinitely. 
 
 
Hand class: Holds five cards for a player, with methods to replace and order cards within it. Each 
player has one opportunity per round of the game (in rounds 1-4) to swap up to three cards to improve 
their hand. After this, the winner (or a draw) is determined. 
Hand::dealHand(Deck& deck): Creates a new hand of five cards from a deck, replacing any 
existing cards in the hand. 
Hand::sortValue(): Sorts cards in value order from smallest to largest. 
E.g., a hand with cards 8, Q, 2, A, 2 would be sorted to 2, 2, 8, Q, A, considering A as 14 when not 
part of a straight. 
Hand::sortGroup() : sorts the cards in a hand based on the frequency of each card's value, 
placing the most frequent values first. For example, a hand containing the cards 2, 7, 7, 2, 7 would be 
rearranged to 7, 7, 7, 2, 2, grouping all 7s together followed by the 2s due to the higher frequency of 
7s. If there are groups of equal size, such as two pairs or two triples, the groups are ordered by the 
card value in ascending order. For instance, a hand with cards 6, King, 8, 6, King (where King 
represents a higher value, typically 13) would be sorted to 6, 6, King, King, 8. This is because both pairs (6s and Kings) have the same frequency, and 6 is numerically smaller than King. In cases where 
no multiples are present, meaning all cards have unique values, the method defaults to sorting by 
individual card values in ascending order. This functionality is achieved by calling the 
`sortValue()` method, which organises cards from lowest to highest value. 
 
Hand::getBest(): Calculates the highest value in the hand as shown above and returns, from 
highest to lowest value, a four-character QString: "stfl", "four", "full", "flsh", "strt", "trio", "twop", 
"pair", "high". 
Hand::setHand(const QVector<int>& cardValues): 
Sets a hand to specific cards defined in a five-element integer QVector. 
The first digit (s) of each integer is the suit in alphabetical order: 
1 = club, 2 = diamond, 3 = heart, 4 = spade. 
The next two digits (vv) are the value of the card: 
01 = Ace, 02-10 = number card, 11 = Jack, 12 = Queen, 13 = King. 
These values define Card objects representing the correct card which then replaces the existing hand. 
 
Example: 
Hand::setHand({111, 311, 411, 201, 308}) 
defines the hand: Jack of Clubs, Jack of Hearts, Jack of Spades, Ace of Diamonds, Eight of Hearts. 
For Advanced Gameplay tasks: 
Hand::swapCard(const QVector<int>& cardIndices, Deck& deck): Replaces up to 
three specified cards with the next card in the deck. 
 
Examples: 
myHand.swapCard({1, 3}, myDeck); 
replaces the first and third cards in deck ‘myDeck’. 
myHand.swapCard({3, 4, 5}, myDeck); 
replaces the third, fourth, and fifth cards in deck ‘myDeck’. 
myHand.swapCard({1, 3, 1}, myDeck); 
replaces the first and third cards and ignores the duplication of the first card. 
myHand.swapCard({1, 3, 4, 5}, myDeck); 
replaces cards 1, 3, and 4; the fourth value is ignored. 
myHand.swapCard({}, myDeck); 
does nothing. 
Order does not matter, e.g., myHand.swapCard({3, 4, 5}, myDeck); 
is the same as myHand.swapCard({5, 3, 4}, myDeck); 
 
请加QQ：99515681  邮箱：99515681@qq.com   WX：codinghelp