program代做、代写C++程序语言

日期：2024-05-09 08:42

1. Deadline:

Tuesday 14th May 2024

(Feedback to be released on 4th 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.

If you are not familiar with the standard 52 card deck of playing cards, Wikipedia goes into lots of

detail here: https://en.wikipedia.org/wiki/Standard_52-card_deck which you may find informative.

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.

Player has a hand of |10♠|10♥|2♣|3♣|5♦| and Computer has a hand of

|10♦|10♠|9♣|6♥|4♠|

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);