Program 2 Crazy Eights Solution

For this assignment, you will write a program that allows one player to play a game of Crazy Eights against the computer. Crazy Eights is a game that uses a standard deck of 52 cards. Specifically, each card has a rank and a suit. There are 13 ranks: the numbers 2 through 10, Jack (usually represented with the letter J), Queen (Q), King (K), and Ace (A). There are 4 suits: clubs, diamonds, hearts, and spades. In a 52-card deck, there is one card of each rank for each suit.

A game of Crazy Eights between two players proceeds as follows:

The deck of cards is shuffled, randomizing the order of the cards.


Each player is dealt 7 cards.


The remaining cards are placed face-down (i.e. with their rank and suit hidden) in a stack on the table and becomes the "stock", with the top card turned over and displayed in a separate "pile".

One of the players (player A) begins the game by playing a card from their hand that is the same suit or same rank as the top card on the pile, which becomes the new top of the pile.

Player B then plays a card from their hand that is the same suit or rank as the top card, which becomes the new top of the pile.

If a player does not have any cards of the required rank or suit, they must draw from the top of the deck (stock) and add cards to their hand until they draw a card that can be played on the pile, or until the deck runs out of cards.

The game continues with the players alternating turns until one of the players gets rid of all the cards in their hand, or until all of the cards are drawn and no one can play a card. If neither player has zero cards at the end of the game, the player with the least amount of cards in their hand wins.

 Eights of any suit are considered "wild" and may be played on any turn. When an eight is played, the player must specify a suit for the next player to match.

Needed classes

To write your Crazy Eights game, you should implement the following classes, including the specified members and methods. You may also add more members and methods, as needed.


class Card {

private:
int rank;    // Should be in the range 0-12.

int suit;    // Should be in the range 0-3.

public:

https://canvas.oregonstate.edu/courses/1810790/assignments/8378384?module_item_id=20842791    1/6
3/23/22, 9:26 PM    Program 2

// may have constructors, destructor, accessor methods, and mutator methods

};

In the Card class above, rank and suit are represented with int values, but you must also have some way to map those values to representations players will be familiar with (e.g. a string representation of the suit or rank).


class Deck {

private:

Card cards[52];

int n_cards;    // Number of cards remaining in the deck.
public:

// may have constructors, destructor, accessor methods, and mutator methods

};

The Deck class is the source of all of the cards. Cards will initially start in a Deck object and then be transferred to players' hands. An important method that should be implemented for the Deck class is one to remove a card and return it so it can be placed in a player's hand (deal a card from the deck to the player).


class Hand {

private:

Card* cards;

int n_cards;    // Number of cards in the hand.
public:

// must have constructors, destructor, accessor methods, and mutator methods

};

The Hand class will hold the cards in one player's hand. The number of cards a player holds may change, so the size of the array of Card objects in a hand may also need to change. Cards may be added to a player's hand and removed from a player's hand, so the Hand class will need functions to do both of those things. Other useful methods might check for a given suit or rank.


class Player {

private:
Hand hand;

std::string name;

public:

// may have constructors, destructor, accessor methods, and mutator methods
};


The Player class represents a single player. Each Player will have a Hand object representing its hand. Depending on how you implement things, the Player class may need methods to add and remove cards from their hand or to check their hand for cards with a specific suit or rank. Another useful method the Player class might have is one to figure out what suit they want to ask for if they play an eight. Note that the Player class must represent both the human player and the computer player. You should write your class methods accordingly and add any extra data members needed to accomplish this.


class Game {

private:

Deck cards;

https://canvas.oregonstate.edu/courses/1810790/assignments/8378384?module_item_id=20842791    2/6
3/23/22, 9:26 PM    Program 2

Player players[2];

public:

// may have constructors, destructor, accessor methods, and mutator methods

}

The Game class represents the state of an entire game. It contains objects representing the deck of cards and both players. It would be useful to have methods in the Game class that check whether the game is over and that execute a player's turn.

Program features

Your program should do the following:

Set up a deck of 52 cards as described above.


Shuffle the deck (i.e. randomize the order of cards).


Deal the cards to the two players.


Play a game of Crazy Eights as described above, with the following gameplay features:


Print the current state of the game (e.g. the cards held by the human player and the card of on the top of the pile) at the start of each turn (keeping the computer player's cards hidden).

On the human player's turn, prompt the user for a card to play. If they cannot play any card, let them know that they will have to draw a card. When they enter a card, either put the card on top of the pile or have them draw a card from the deck if they can't play. If the user chooses to play an 8, prompt the user to declare a suit for the next player.

Once the game is over, you should announce the winner and ask the user if they want to play again.


You should not have any memory leaks in your program.


Note: You cannot use the vector class for handling dynamic memory


(5 pts) Extra Credit

When you print the state of the game (at the beginning of each turn), also indicate to the user which cards in their hand are valid options to be played.

You could implement this behavior in many different ways, but I would suggest printing a special symbol (such as a *) next to the cards that possible choices.

Programming Style/Comments


In your implementation, make sure that you include a program header. Also ensure that you use proper indentation/spacing and include comments! Below is an example header to include. Make sure you review the style guidelines for this class, and begin trying to follow them, i.e. don’t align everything on the left or put everything on one line!

Style Guidelines: cpp_style_guideline.pdf

(https://web.engr.oregonstate.edu/~goinsj/resources/general/cpp_style_guideline.pdf)


/******************************************************

** Program: crazyeights.cpp

https://canvas.oregonstate.edu/courses/1810790/assignments/8378384?module_item_id=20842791    3/6
3/23/22, 9:26 PM    Program 2

    • Author: Your Name

    • Date: xx/xx/2021

    • Description:

    • Input:

    • Output:

******************************************************/




When you compile your code, it is acceptable to use C++11 functionality in your program. In order to support this, change your Makefile to include the proper flag.
Consider the following approach (which also includes debugging support):


g++ -std=c++11 -Wall -g other flags and parameters



In order to submit your homework assignment, you must create a tarred archive that contains your .h, .cpp, and Makefile files. This tar file will be submitted to Canvas. In order to create the tar file, use the following command:


tar –cvf assign2.tar list_of_all_the_.h_and_.cpp_files Makefile


Grading


You are required to meet with a TA within two weeks of the assignment due date to demo and receive a grade. You can schedule a demo with a TA online using the link provided on the TAs page. You must use your OSU email to schedule (for FERPA reasons), or your appointment will be cancelled.

Programming assignments that do not compile and run on the OSU ENGR servers will receive a grade of zero, with no exceptions.


Crazy 8s

























https://canvas.oregonstate.edu/courses/1810790/assignments/8378384?module_item_id=20842791    4/6
3/23/22, 9:26 PM
Program 2










Criteria

Ratings
Pts







Game Initialization


9 pts

Student correctly initializes the game with 52 cards and 2 players















Deck Initialization


9 pts

Student correctly shuffles and deals cards from deck to players















Turns


9 pts

Student correctly alternates turns between players















Playing Cards


9 pts

Student correctly transfers cards from player hands to pile on their turn













Drawing Cards


9 pts

Student correctly transfers cards from deck to player hands until they can play a card













File Separation & Makefile




Student correctly separates code into appropriate interface, implementation, and driver files and

9 pts

has a working Makefile for compilation, and submits via a single tarball.









Comments & Style




Student appropriately comments code and uses a consistent and appropriate style. At a



minimum, header should contain author's name and a description of the program.

9 pts

Is code easy for the TA to read? Conditional blocks of code should always be indented. Every



function contains it's own initial block comment (or multiple lines of comments prior to the



function definition) that provides the reader with an explanation of the function's purpose. -1 pt



for each function that is missing a header (up to 5 point penalty).










Winning


9 pts

Student correctly determines when the game is over and who the winner is













Required Classes




Student correctly implements each of the required classes (Card, Deck, Hand, Player, Game)



April
19th clarification: This also means that students must implement constructors (specifically







7 pts

the copy constructor), a destructor, and assignment operator overload for classes that utilize



dynamically allocated memory.




Your member variables must exactly match the prototypes given in the assignment (though you



can also add more members if needed).










Memory Cleanup




The Valgrind LEAK SUMMARY should report: "definitely lost: 0 bytes in 0 blocks". Each "new"

3 pts

operation should have a corresponding delete operation.














https://canvas.oregonstate.edu/courses/1810790/assignments/8378384?module_item_id=20842791    5/6
3/23/22, 9:26 PM
Program 2







Criteria

Ratings
Pts






Program Functionality


3 pts

Program does not crash during testing (e.g. segmentation fault or similar abrupt halts)












Function Modularity


5 pts

No functions longer than approximately 20 lines of code.














Extra credit (5pts)




Students earn 5 points of extra credit if their solution correctly indicates which cards in the

0 pts

human player's hand are valid choices for the current turn.









(The grader will add 5 pts if the requirement is met.)











Total Points: 90
























































https://canvas.oregonstate.edu/courses/1810790/assignments/8378384?module_item_id=20842791    6/6