Description
Ⅰ. Background
The Cultural Festival turned out a success for SOS Brigade . After struggling for making the movie
for so long, they finally went back to their normal routine. However, a group of five huge men
broke into their club activity room and asked the members of SOS Brigade to play their designed
game Blackjack . Actually, the computer storing SOS Quantum Library (see Lab1 ex.1) originally
belonged to Joseph Joestar , but Suzumiya Haruhi robbed it. At that time Joseph was busy
with dealing with Dio Brando and did not have time to deal with Haruhi . Now Dio Brando is
dead and Joseph comes back to get his computer back. The Stardust Crusaders led by Joseph
Jostar will compete SOS Brigade led by Suzumiya Haruhi through this game. Joseph Jostar
will borrow 4 computers to SOS Brigade . If Stardust Crusaders wins, Joseph will get his
computer back and get a member of SOS Brigade into Stardust crusaders . If SOS Brigade
wins, those four computers will belong to SOS Brigade and Stardust Crusaders will be an
affiliate group of SOS Brigade .
Ⅱ. Introduction
You need to firstly help Joseph Joestar to implement this card game. It is played with a
standard deck of 52 playing cards. There are two participants, a dealer and a player. The player
starts with a bankroll, and the game progresses in hands and rounds.
At the start of each hand, the player decides how much to wager on this hand. The wager is an
integer greater or equal to a minimum allowable wager and less than or equal to the player’s
total bankroll.
After the wager, the dealer deals a total of four cards:
1. face-up to the player,
2. face-up to the dealer,
3. face-up to the player,
4. face-down to the dealer, hole card.
The player then examines his cards and calculate the total number of his card’s worth. Different
cards have different worth:
2-10 is worth its spot value
face card (jack, queen, king) is worth 10
Ace is worth 1 or 11, depending on which is more advantageous to the player.
If the total includes an ace counted as 11, the total is called soft, otherwise it is called hard.
The game progresses first with the player, then the dealer. The player’s goal is to build a hand that
is as close to 21 as possible without going over—the latter is called a bust, and a player who busts
loses the hand and his bankroll will decrease by his wager. For cards whether soft or hard,
players/dealers only care about the current situation, i.e. they are greedy. They do not have the
ability to foresee. As long as the player believes another card will help, the player hits—asks the
dealer for another card. Each of these additional cards is dealt face-up. This process ends either
when the player decides to stand—ask for no cards, or the player busts. Note that a player can
stand with two cards; one need not hit at all in a hand.
Natural 21: The player is dealt an ace plus any 10 or face card (jack, queen, king) in his hand. His
bankroll will increase by wager * 3 / 2.
If the player neither busts nor is dealt a natural 21, play then progresses to the dealer. The dealer
must hit until he either reaches a total greater than or equal to 17 (hard or soft), or busts. If the
dealer busts, the player wins. Otherwise, the two totals are compared:
If the dealer’s total is higher, the player’s bankroll decreases by the amount of his wager.
If the player’s total is higher, his bankroll increases by the amount of his wager.
If the totals are equal, the bankroll is unchanged; this is called a push.
A hand ends in four cases:
1. The player get paid.
2. The player’s bankroll decreases.
3. They push.
4. The cards are used up, then they shuffle the cards and do this hand again.
A round consists of several hands. There is a maximum number of hands for each rounds. A
round will end whenever one player is kicked out. A round ends in two cases:
1. The player’s bankroll cannot reach that minimum allowable wager. Then the player is kicked
out and a new round start from Hand 1. The dealer’s remaining hand will be reset to the
maximum number of hands.
2. Otherwise, if the allotted hands are all played and the player’s bankroll can still reach that
minimum allowable wager, then the dealer is kicked out and a new round start from Hand
1. The player’s remaining hand will be reset to the maximum number of hands.
During the whole game process (before all the members of one team are kicked out), they will use
the same set of cards, i.e. the cards will not be reset after the game starts.
When one round ends and the player wins, the bankroll will not be reset to the start bankroll.
Instead, everyone will be provided the bankroll only when they enter the game. During the game
process, i.e. the player has not been kicked out, the player can only get money from the dealer.
When the player is kicked out of the game, he/she will not pass his/her remaining money to the
next player.
Ⅲ. Programming Assignment
You will provide implementations of four separate abstractions for this project: a deck of cards, a
blackjack hand, a blackjack player, and a game driver. All files referenced in this specification are
located in the Projects/Project3 folder on Canvas.
1. The Deck ADT
Your first task is to implement the following ADT and put your implementation into a file named
deck.cpp .
class DeckEmpty { // An exception type
};
const int DeckSize = 52;
The Deck ADT is specified in deck.h . The Deck ADT depends on the following Card type declared
in card.h The file card.cpp defines SpotNames, SuitNames, SOS_Name, SC_Name for you, so
that SuitNames[HEARTS] is the char string “Hearts”, and so on.:
class Deck {
// A standard deck of 52 playing cards—no jokers
Card deck[DeckSize]; // The deck of cards
int next; // The next card to deal
public:
Deck();
// EFFECTS: constructs a “newly opened” deck of cards. first the
// spades from 2 to A, then the hearts, then the clubs, then the
// diamonds. The first card dealt should be the 2 of Spades.
void reset();
// EFFECTS: resets the deck to the state of a “newly opened” deck
// of cards.
void shuffle(int n);
// REQUIRES: n is between 0 and 52, inclusive.
// MODIFIES: this
// EFFECTS: cut the deck into two segments: the first n cards,
// called the “left”, and the rest called the “right”. Note that
// either right or left might be empty. Then, rearrange the deck
// to be the first card of the right, then the first card of the
// left, the 2nd of right, the 2nd of left, and so on. Once one
// side is exhausted, fill in the remainder of the deck with the
// cards remaining in the other side. Finally, make the first
// card in this shuffled deck the next card to deal. For example,
// shuffle(26) on a newly-reset() deck results in: 2-clubs,
// 2-spades, 3-clubs, 3-spades … A-diamonds, A-hearts.
//
// Note: if shuffle is called on a deck that has already had some
// cards dealt, those cards should first be restored to the deck
// in the order in which they were dealt, preserving the most
// recent post-shuffled/post-reset state. After shuffling, the
// next card to deal is the first one in the deck.
Card deal();
// MODIFIES: this
// EFFECTS: returns the next card to be dealt. If no cards
// remain, throws an instance of DeckEmpty.
int cardsLeft();
// EFFECTS: returns the number of cards in the deck that have not
// been dealt since the last reset/shuffle.
};
enum Suit {
SPADES, HEARTS, CLUBS, DIAMONDS
};
enum Team {
2. The Hand Interface
Your second task is to implement Hand APT specified in hand.h and put your implementation
into a file named hand.cpp .
SOSBrigade, StardustCrusaders
};
enum Spot {
TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE
};
extern const string SuitNames[DIAMONDS + 1];
extern const string SpotNames[ACE+1];
extern const string SOS_Name[5]; // The full name of each member in SOS Brigade
extern const string SC_Name[5]; // The full name of each member in Stardust
Crusaders
struct Card {
Spot spot;
Suit suit;
};
struct HandValue {
int count; // Value of hand
bool soft; // true if hand value is a soft count
};
class Hand {
// OVERVIEW: A blackjack hand of zero or more cards
// Note: this really is the only private state you need!
HandValue curValue;
public:
Hand();
// EFFECTS: establishes an empty blackjack hand.
void discardAll();
// MODIFIES: this
// EFFECTS: discards any cards presently held, restoring the state
// of the hand to that of an empty blackjack hand.
void addCard(Card c);
// MODIFIES: this
// EFFECTS: adds the card “c” to those presently held.
HandValue handValue() const;
// EFFECTS: returns the present value of the blackjack hand. The
// count field is the highest blackjack total possible without
// going over 21. The soft field should be true if and only if at
// least one ACE is present, and its value is counted as 11 rather
// than 1. If the hand is over 21, any value over 21 may be
// returned.
};
3. The Player Interface
Your third task is to implement two different blackjack players, specified in player.h . You are to
implement two different derived classes from this interface and put them in a file named
player.cpp .
class Player {
// A virtual base class, providing the player interface
protected:
Team team; // The team of each member, either SOS Brigade or Stardust
Crusaders
int ID; // The ID of each member.
string name; // The full name of each member.
public:
virtual int bet(unsigned int bankroll,
unsigned int minimum) = 0;
// REQUIRES: bankroll >= minimum
// EFFECTS: returns the player’s bet, between minimum and bankroll
// inclusive
virtual bool draw(Card dealer, // Dealer’s “up card”
const Hand &player) = 0; // Player’s current hand
// EFFECTS: returns true if the player wishes to be dealt another
// card, false otherwise.
virtual void expose(Card c) = 0;
// EFFECTS: allows the player to “see” the newly-exposed card.
// For example, each card that is dealt “face up” is exposed, i.e. expose().
// Likewise, if the dealer must show his “hole card”, it is also exposed,
i.e.
// expose(). Note: not all cards dealt are exposed, i.e. expose()—if the
// player goes over 21 or is dealt a natural 21, the dealer need
// not expose his hole card.
virtual void shuffled() = 0;
// EFFECTS: tells the player that the deck has been re-shuffled.\
virtual string getName();
// EFFECTS: get the full name of the player.
virtual int getID();
// EFFECTS: get the ID of the player.
virtual Team getTeam();
// EFFECTS: get the team of the player.
virtual void setPlayer(Team tm, int id);
// EFFECTS: set a member’s name, ID and team
// MODIFIES: name, ID, team
virtual ~Player() { }
// Note: this is here only to suppress a compiler warning.
// Destructors are not needed for this project.
};
The first derived class is the simple player, who plays a simplified version of basic strategy for
blackjack. The simple player always places the minimum allowable wager, and decides to hit or
stand based on the following rules and whether or not the player has a hard count or soft
count:
The first set of rules apply if the player has a hard count, i.e., his best total counts an Ace (if any)
for 1, not 11.
If the player’s hand totals 11 or less, he always hits.
If the player’s hand totals 12, he stands if the dealer shows 4, 5, or 6; otherwise he hits.
If the player’s hand totals between 13 and 16 inclusive, he stands if the dealer shows a 2
through a 6 inclusive; otherwise he hits.
If the player’s hand totals 17 or greater, he always stands.
The second set of rules applies if the player has a “soft count” , i.e., his best total includes one
Ace worth 11. (Note that a hand would never count two Aces as 11 each–that’s a bust of 22.)
If the player’s hand totals 17 or less, he always hits.
If the player’s hand totals 18, he stands if the dealer shows a 2, 7, or 8, otherwise he hits.
If the player’s hand totals 19 or greater, he always stands.
Note: the Simple player does nothing for expose and shuffled events.
The second derived class is the Counting player. This player counts cards in addition to playing
the basic strategy. The intuition behind card counting is that when the deck has more face cards
(worth 10) than low-numbered cards, the deck is favorable to the player. The converse is also
true.
The Counting player keeps a running “count” of the cards he’s seen from the deck. Each time he
sees (via the expose() method) a 10, Jack, Queen, King, or Ace, he subtracts one from the count.
Each time he sees a 2, 3, 4, 5, or 6, he adds one to the count. When he sees that the deck is
shuffled(), the count is reset to zero. Whenever the count is +2 or greater and he has enough
bankroll (larger than or equal to the double of the minimum), the Counting player bets double
the minimum, otherwise (i.e., including the situation where count >= +2 but the bankroll is less
than the double of the minimum) he bets the minimum. The Counting player should not reimplement methods of the Simple player unnecessarily.
You must also declare static global instances of each of the Players you implement in your
player.cpp file. Finally, you should implement “access” functions like this that return pointers to
each of these global instances in your player.cpp file. You should use this single function to get
any player.
extern Player* get_Player(string& dealerSide, string& playerType, int& ID);
// EFFECTS: get a pointer to a player.
// “dealerSide” describes whether the dealer
is from SOS Brigade or Stardust Crusade. This depends on the last program
argument: [sos|sc]. sc means the dealer team is Stardust Crusaders, sos means the
dealer team is SOS Brigade.
// “playerType” describes whether Koizumi Itzuki and Mohammed Avdol are simple p
layer or count player. This depends on the penultimate program argument:
[simple|counting]. If this argument is “simple”, then Itzuki and Avdol are simple
players. If this argument is “counting”, then Itzuki and Avdol are
countingplayers.
// “ID” is the player’s ID.
4. Characters
There are in total 10 people in this game who have different characteristics. They are from two
sides. Normally, they have same bankroll and same hands. One team will be selected as player
team and the other will be dealer team. This depends on program arguments. In “[]” are
characteristics that these people have only when they are players. The ID of each character is
given after the name of each character. i.e. The IDs of Kyon and Kakyoin Noriaki are both 4.
SOS Brigade
1. Suzumiya Haruhi (ID: 1) Leader of SOS Brigade. [Due to her preference to make things
simple, she is a simple player. But she is very brave, she always bets double the minimum.]
2. Nagato Yuki (ID: 2) Human interface alien. [She is a normal counting player.]
3. Asahina Mikuru (ID: 3) Not good at games. [She is a counting player, but she will act
contrary to a counting player, i.e. she will double the minimum only when the count is less
than -2 and she has enough bankroll.]
4. Kyon (ID: 4) [He is a simple player.]
5. Koizumi Itzuki (ID: 5) [His player type (simple or count) depends on user input.]
Stardust Crusaders
1. Joseph Joestar (ID: 1) Leader of Stardust Crusaders. [He is a rich counting player, having 2
times of normal bankroll as his own bankroll, but he fears being poor. If his bankroll is less
than one half of the normal bankroll, he will escape, shout “Ni Ge Run Da Yo” (Escape fast in
Japanese) and lost the game.] If he successfully kicks out an enemy, he will cheer “Nice!”.
2. Kujo Jotaro (ID: 2) [He is a count player.] However, every time he is about to bust, he will
shout “Star Platinum, Za Warudo” to activate his stand power, stop the time, abandon his
current cards and take the same number of cards again. He will stop time for multiple times
until he got a set of cards that will not bust (natural 21 will still be valid). He will not expose
his card got when time is stopped. It may happen that the cards are used up. Please note
that dealers can also bust.
3. Jean Pierre Polnareff (ID: 3) [He is a simple player.]
4. Kakyoin Noriaki (ID: 4) [He is a very cautious count player so that he will only bet double the
minimum when count >= +4 and he has enough bankroll.] After he defeats an enemy, he will
eat a cherry, producing a sound of “rerorerorero rerorerorero”.
5. Mohammed Avdol (ID: 5) [His player (simple or count) type depends on user input.]
For SOS Brigade, they will come into the game according to the sequence: Suzumiya Haruhi ->
Nagato Yuki -> Asahina Mikuru -> Kyon -> Koizumi Itzuki. For Stardust Crusaders, they will
come into the game according to the sequence: Joseph Joestar -> Kujo Jotaro -> Jean Pierre
Polnareff -> Kakyoin Noriaki -> Mohammed Avdol . The detailed kick-out rule is in 5. The
Driver Program .
5. The Driver Program
Finally, you are to implement a driver program that can be used to simulate this version of
blackjack given your implementation of the ADTs described above and put your implementation
into a file named blackjack.cpp .
The driver program, when run, takes four arguments:
The first argument is an integer denoting the player’s starting bankroll. The second argument is
the maximum number of hands for each player to play in the simulation. You can assume that
these two integers input by the user are positive (≥1) and within an upper limit of 10000.
The third argument is one of the two strings “simple” or “counting”, denoting those player’s type
(simple or counting) which will depend on program arguments. The fourth argument decides
which team is the dealer team.
For example, suppose that you program is called blackjack. It may be invoked by typing in a
terminal:
Then Koizumi Itzuki and Mohammed Avdol are simple players. The dealer team will be
Stardust Crusaders . Each player will have at most 3 hands. When one person is kicked out, the
other’s remaining hand will be reset to 3.
The driver first shuffles the deck. To shuffle the deck, you choose seven cuts between 13 and 39
inclusive at random, shuffling the deck with each of these cuts. We have supplied a header,
rand.h , and an implementation, rand.cpp , that define a function that provides these random
cuts. Each time the deck is shuffled, first announce it:
And announce each of the seven cut points:
then be sure to tell the player via shuffle().
Note: you should always print the message corresponding to the initial shuffling before you do
anything further.
We assume that the minimum bet is 5. Then, while the player’s bankroll is larger than or equal to
the minimum bet of 5 and there are hands left to be played:
Announce the hand:
where the variable thishand is the hand number, starting from 1.
If there are fewer than 20 cards left, reshuffle the deck as described above. Note that this
happens only at the beginning of each hand. It does not occur during a hand even if the
number of cards is fewer than 20.
Ask the player for a wager and announce it:
where Player_Fullname is current player’s full name.
Deal four cards: one face-up to the player, one face-up to the dealer, one face-up to the
player, and one face-down to the dealer. Announce the face-up cards using cout. For
example:
./blackjack 100 3 simple sc
cout << "Shuffling the deck" << endl;
cout << "cut at " << cut << endl;
cout << "Hand " << thishand << " bankroll " << bankroll << endl;
cout << "Player: " << Player_Fullname << " bets " << wager << endl;
Use the SpotNames, SuitNames, SOS_Name, SC_Name arrays for this, and be sure to expose()
any face-up cards to the player.
If the player is dealt a natural 21, immediately pay the player 3/2 of his bet. In this case,
announce as below, and this hand ends:
If the player is not dealt a natural 21, have the player play his hand. Draw cards until the
player either stands or busts. Announce and expose() each card dealt as above.
When drawing cards ends, Kujo Jotaro will know whether he should stop the time. If he is
about to bust, he will immediately shout
activate his stand power, stop the time and take the same number of cards. He will not
expose his cards, or his stopping-time action will be discovered. The time will begin to flow
after he get the same number of cards. However, if he finds that he is about to bust again, he
will stop the time again.
After Kujo Jotaro flows the time, he will check whether he should stand. If not, he will keep
getting cards according to the rule. However, it may happen that he is again about to bust,
then he should stop the time again...
Announce the player's total
where the variable player_count is the total value of the player’s hand. If the player busts,
say so:
deducting the wager from the bankroll and moving on to the next hand. If Kujo Jotaro
stops the time, he will not announce his total before time is stopped. He will only announce
his total if he will not bust.
If the player hasn’t busted, announce and expose the dealer’s hole card. For example:
(Note: the hole card is NOT exposed if either the player busts or is dealt a natural 21.)
If the player hasn’t busted, play the dealer’s hand. The dealer must hit until reaching
seventeen or busting. Announce and expose each card as above.
At this time, Kujo Jotaro will know whether he should stop the time. If he is about to bust,
he will immediately shout
Player: Suzumiya Haruhi dealt Ace of Spades
Dealer: Joseph Joestar dealt Two of Hearts
cout << "Player: " << Player_Fullname << " dealt natural 21" << endl;
Player: Kujo Jotaro: "Star Platinum, Za Warudo"
cout << "Player: " << Player_Fullname << "'s total is " << player_count <<
endl;
cout << "Player: " << Player_Fullname << " busts" << endl;
Dealer: Joseph Joestar's hole card is Ace of Spades
activate his stand power, stop the time and take the same number of cards. He will not
expose his cards, or his stopping-time action will be discovered. The time will begin to flow
after he get the same number of cards. However, if he finds that he is about to bust again, he
will stop the time again.
After Kujo Jotaro flows the time, he will check whether he should stand. If not, he will keep
getting cards according to the rule. However, it may happen that he is again about to bust,
then he should stop the time again...
Announce the dealer’s total
where the variable dealer_count is the total value of the dealer’s hand. If the dealer busts,
say so:
crediting the wager from the bankroll and moving on to the next hand.
If neither the dealer nor the player bust, compare the totals and announce the outcome.
Credit the bankroll, debit it, or leave it unchanged as appropriate.
If the player's bankroll is larger than or equal to the minimum bet of 5 and there are hands
left to be played, then continue to play the next hand (i.e., start again from the first bullet
point “Announce the hand”).
When the player either has too little money to make a minimum wager or the allotted hands
have been played, announce the outcome:
where the variable thishand is the current hand number. In the special case where the initial
bankroll is less than the minimum, we have thishand = 0, since the player hasn’t played any
hand yet. Furthermore, in this special case, the initial shuffling of the deck should still be
announced before you print the status of the player.
At this time, Joseph Joestar will know whether he should escape. If he will, the output
should be as below:
At this time, if the allotted hands have all been played and the player have enough money to
at least make a minimum wager, the player will win this round (not hand. A round consists
Dealer: Kujo Jotaro: "Star Platinum, Za Warudo"
cout << "Dealer: " << Dealer_Fullname << "'s total is " << dealer_count <<
endl;
cout << "Dealer: " << Dealer_Fullname << " busts" << endl;
cout << "Dealer: " << Dealer_Fullname << " wins this hand" << endl;
cout << "Player: " << Player_Fullname << " wins this hand" << endl;
cout << "Push" << endl;
cout << "Player: " << Player_Fullname << " has " << bankroll << " after "
<< thishand << " hands" << endl;
Player: Joseph Joestar: "Ni Ge Run Da Yo"
of those allotted hands) and the dealer will be kicked out of the game. The next dealer will
come and start a new round from Hand 1. The program will announce the outcome:
If the player has too little money to make a minimum wager, the dealer wins this round, and
the player will be kicked out of the game. The next player will come and start a new round
from Hand 1.
At this time, Joseph Joestar and Kakyoin Noriaki will get to know whether they wins. If
they wins, they will cheer after the "kick-out" message like this:
If the cards are used up, this hand will immediately be stopped, output the below message,
shuffle the card and start this hand again.
When all the members of one team are kicked out, game ends. The program's output
depends on the winning side. For example,
Messages after # should not go to output. They are just comments.
IV. Implementation Requirements and Restrictions
You may include
other system header files may be included, and you may not make any call to any function in
any other library.
Output should only be done where it is specified.
You may not use the goto command.
You may not have any global variables in the driver. You may use global state in the class
implementations, but it must be static and (except for the two players) const .
There is no user input. You may assume that functions are called consistent with their
advertised specifications. This means you need not perform error checking. However, when
testing your code in concert, you may use the assert() macro to program defensively.
cout << "Dealer: " << Dealer_Fullname << " has been kicked out. The winner of
this round is "<< Player_Fullname <<"." << endl;
cout << "Player: " << Player_Fullname << " has been kicked out. The winner of
this round is "<< Dealer_Fullname <<"." << endl;
Player: Kakyoin Noriaki: "rerorerorero rerorerorero"
Dealer: Joseph Joestar: "Nice!"
cout << "Hand " << thishand << " card used up, this hand will start again"
<< endl;
Game over. The winner is Stardust Crusaders. SOS Brigade will return the computer
to Joseph Joestar and Suzumiya Haruhi will become a member of Stardust Crusaders
# When Stardust Crusaders wins
Game over. The winner is SOS Brigade. SOS Brigade got four computers and Stardust
Crusaders become an affiliate group of SOS Brigade # When SOS Brigade wins
V. Source Code Files and Compiling
There are five header files ( card.h , deck.h , hand.h , player.h , and rand.h ) and two C++
source files ( card.cpp and rand.cpp ) located in the Project3_starter_file.zip from our
Canvas resources:
You should copy these files into your working directory. DO NOT modify them!
You need to write four other C++ source files: deck.cpp , hand.cpp , player.cpp , and
blackjack.cpp . They are discussed above and summarized below:
deck.cpp : your Deck ADT implementation
hand.cpp : your Hand ADT implementation
player.cpp : your player ADT implementations
blackjack.cpp : your simulation driver
After you have written these files, you can type the following command in the terminal to compile
the program:
This will generate a program called blackjack in your working directory. In order to guarantee that
the TAs compile your program successfully, you should name you source code files exactly like
how they are specified above. For this project, the penalty for code that does not compile will be
severe, regardless of the reason. You should submit four source code files deck.cpp , hand.cpp ,
player.cpp , and blackjack.cpp (in one compressed file) via JOJ. The due time is 23:59 on July
9th, 2021.
Ⅵ. Grading
Your program will be graded along three criteria:
1. Functional Correctness
2. Implementation Constraints
3. General Style
Functional Correctness is determined by running a variety of test cases against your program,
checking against our reference solution. We will grade Implementation Constraints to see if you
have met all of the implementation requirements and restrictions. General Style refers to the
ease with which TAs can read and understand your program, and the cleanliness and elegance of
your code. For example, significant code duplication will lead to General Style deductions.
VIII. Last
The game SOS Brigade played is actually The Day of Sagittarius Ⅲ , originally designed as a
competition between Computer Research Club and SOS Brigade in The Melancholy of
Haruhi Suzumiya 2009 , episode 27 The Day of Sagittarius . You can watch the original game
playing process in bilibili (need a VIP) or in 5dm (better subtitle, less danmaku).
g++ -Wall –o blackjack blackjack.cpp card.cpp deck.cpp hand.cpp player.cpp
rand.cpp
I am currently working on The Day of Sagittarius Ⅳ , another game based on the same
background as this project. Hopefully it will become a potential future project of VE280.
The game Stardust Crusaders played is in the chapter of D'Arby the Player which is also
quite splendid. This is in JoJo's Bizarre Adventure: Stardust Crusaders, episode 60 & 61 .
You can watch it in bilibili (need a VIP)
Hope you will enjoy this project. Have fun!
