Skip to content
Snippets Groups Projects
Commit db4155de authored by iliya's avatar iliya
Browse files

Merge branch '1-part-2-blackjack-implementation'

parents f0f31ecd 59407833
No related branches found
No related tags found
No related merge requests found
.idea/
target/
.classpath
.project
.settings/
*.bak
package hepia;
import java.util.ArrayList;
import java.util.List;
/**
* AIPlayer
*/
public class AIPlayer implements IPlayer {
private int bet;
private Hand hand;
private List<Hand> splittedHand;
private double balance;
private boolean hasInsurance;
private int insuranceBet;
private boolean hasDoubledBet;
@Override
public boolean hasSplitHand() {
if (splittedHand != null) {
return true;
}
return false;
}
@Override
public void splitHand() {
splittedHand = new ArrayList<>();
for (int i = 0; i < hand.size(); i++) {
splittedHand.add(new Hand(this.hand.getCardFromHand(i)));
}
this.bet *= 2;
}
@Override
public List<Hand> getSplittedHand() {
return splittedHand;
}
@Override
public boolean hasDoubledBet() {
return hasDoubledBet;
}
public void setDoubledBet(boolean doubledBet) {
if (doubledBet) {
this.bet *= 2;
}
this.hasDoubledBet = doubledBet;
}
@Override
public int getInsuranceBet() {
return insuranceBet;
}
@Override
public boolean hasInsurance() {
return hasInsurance;
}
public void setHasInsurance(boolean hasInsurance) {
if (hasInsurance) {
insuranceBet = this.bet / 2;
}
this.hasInsurance = hasInsurance;
}
@Override
public void addToBalance(double amount) {
this.balance += amount;
}
@Override
public double getBalance() {
return this.balance;
}
@Override
public void setHand(Hand hand) {
this.hand = hand;
}
@Override
public Hand getHand() {
return hand;
}
public AIPlayer(int bet) {
placeBet(bet);
this.balance = 0.0;
}
@Override
public void placeBet(int valueOfBet) {
this.bet = valueOfBet;
}
@Override
public int getBet() {
return this.bet;
}
@Override
public void receiveHand(Hand hand) {
this.hand = hand;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("========= AI Player =========\n");
builder.append("Value of bet: " + this.bet + "\n");
builder.append("Current balance: " + this.balance + "\n");
builder.append("Hand: " + this.hand + "\n");
builder.append("Hand value: " + this.hand.computeHandValue() + "\n");
String str = new String(builder);
return str;
}
}
package hepia;
import java.util.ArrayList;
import java.util.Scanner;
/**
* App
*/
public class App {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int nbAIplayers = 0;
int nbDecks = 5;
while (true) {
System.out.println("Please select an option:");
System.out.println("\t1) Create a deck of cards");
System.out.println("\t2) Shuffle deck of cards");
System.out.println("\t3) Print state of deck (aka game)");
System.out.println("\t4) Give out two hands");
System.out.println("\t5) Display boths hands in a sorted manner");
System.out.println("\t6) Create a pack of decks");
System.out.println("\t7) Display a pack");
Scanner scanner = new java.util.Scanner(System.in);
int user_input = scan.nextInt();
System.out.print("Please specify the amount of players: ");
int nbPlayers = scanner.nextInt();
switch (user_input) {
case 1:
System.out.println("Select a deck size:");
System.out.println("\t1) 32");
System.out.println("\t2) 52");
System.out.println("\t3) 54");
System.out.println("\t4) 56");
System.out.println("\t5) 78");
int menu_deck_size = scan.nextInt();
Deck deckSize;
GameManager foo = new GameManager(Game.BLACKJACK, nbPlayers, nbAIplayers, nbDecks);
switch (menu_deck_size) {
case 1:
deckSize = new Deck(32);
deckSize.printGame();
break;
case 2:
deckSize = new Deck(52);
deckSize.printGame();
break;
case 3:
deckSize = new Deck(54);
deckSize.printGame();
break;
case 4:
deckSize = new Deck(56);
deckSize.printGame();
break;
case 5:
deckSize = new Deck(78);
deckSize.printGame();
break;
default:
break;
}
foo.runGame();
break;
case 2:
Deck deck = new Deck(54);
deck.shuffleDeck();
deck.printGame();
break;
case 3:
Deck dck = new Deck(54);
dck.printGame();
break;
case 4:
Deck game1 = new Deck(54);
Card[][] hands1 = game1.giveTwoHands();
game1.printHands(hands1);
break;
case 5:
Deck game2 = new Deck(54);
Card[][] hands2 = game2.giveTwoHands();
game2.printSortedHands(hands2);
break;
case 6:
ArrayList<Deck> pack = Deck.getPackOfCards(4, 32);
Deck.printPack(pack);
break;
case 7:
ArrayList<Deck> pack1 = Deck.getPackOfCards(10, 78);
Deck.printPack(pack1);
break;
default:
scan.close();
break;
}
}
scanner.close();
}
}
package hepia;
import java.util.ArrayList;
import java.util.Arrays;
public final class Card {
private final int rank;
private final ISuit suit;
private int weight;
private final static String[] RANK_NAMES = {
private final static ArrayList<String> RANK_NAMES = new ArrayList<>(
Arrays.asList(
"Joker",
"As",
"2",
......@@ -23,10 +25,10 @@ public final class Card {
"Dame", // 13
"Roi", // 14
"Excuse", // 15
"Atout", // 16
};
"Atout" // 16
));
public static String[] getRANK_NAMES() {
public static ArrayList<String> getRANK_NAMES() {
return RANK_NAMES;
}
......@@ -35,7 +37,7 @@ public final class Card {
}
public String getRankName() {
return RANK_NAMES[this.rank];
return RANK_NAMES.get(this.rank);
}
public int getWeight() {
......@@ -51,15 +53,15 @@ public final class Card {
}
private void ensureValidRank(int rank) {
if (rank < 0 || rank > RANK_NAMES.length - 1) {
if (rank < 0 || rank > RANK_NAMES.size() - 1) {
throw new RuntimeException(
"Le rang doit être compris dans l'intervalle [0, " + (RANK_NAMES.length - 1) + "]");
"Le rang doit être compris dans l'intervalle [0, " + (RANK_NAMES.size() - 1) + "]");
}
}
private void ensureValidSpecialSuitAndRank(ISuit suit, int rank) {
if (suit instanceof SpecialSuit) {
if (rank != Arrays.asList(RANK_NAMES).indexOf(suit.toString())) {
if (rank != RANK_NAMES.indexOf(suit.toString())) {
throw new RuntimeException("The value of the rank does not match with the given suit!");
}
}
......@@ -67,8 +69,9 @@ public final class Card {
private void ensureValidColourSuiteAndRank(ISuit suit, int rank) {
if (suit instanceof ColourSuit) {
if (RANK_NAMES[rank] == "Joker" || RANK_NAMES[rank] == "Cavalier" || RANK_NAMES[rank] == "Excuse"
|| RANK_NAMES[rank] == "Atout") {
if (RANK_NAMES.get(rank) == "Joker" || RANK_NAMES.get(rank) == "Cavalier"
|| RANK_NAMES.get(rank) == "Excuse"
|| RANK_NAMES.get(rank) == "Atout") {
throw new RuntimeException("The value of the rank does not match with the given suit!");
}
}
......@@ -87,6 +90,34 @@ public final class Card {
this.weight = weight;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Card)) {
return false;
}
Card toCompare = (Card) obj;
boolean res = true;
if (this.rank != toCompare.rank) {
res = false;
}
if (this.suit != toCompare.suit) {
res = false;
}
if (this.weight != toCompare.weight) {
res = false;
}
return res;
}
@Override
public String toString() {
if (this.suit instanceof ColourSuit) {
......
package hepia;
import java.util.List;
/**
* CroupierPlayer
*/
public class CroupierPlayer implements IPlayer {
private int bet;
private Hand hand;
private double balance;
@Override
public boolean hasSplitHand() {
return false;
}
@Override
public void splitHand() {
}
@Override
public List<Hand> getSplittedHand() {
return null;
}
@Override
public boolean hasDoubledBet() {
return false;
}
@Override
public int getInsuranceBet() {
return 0;
}
@Override
public boolean hasInsurance() {
return false;
}
@Override
public void addToBalance(double amount) {
this.balance += amount;
}
@Override
public double getBalance() {
return this.balance;
}
@Override
public void setHand(Hand hand) {
this.hand = hand;
}
@Override
public Hand getHand() {
return hand;
}
public CroupierPlayer(int bet) {
placeBet(bet);
this.balance = 0.0;
}
@Override
public void placeBet(int valueOfBet) {
this.bet = valueOfBet;
}
@Override
public int getBet() {
return this.bet;
}
@Override
public void receiveHand(Hand hand) {
this.hand = hand;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("========= Croupier Player =========\n");
builder.append("Value of bet: " + this.bet + "\n");
builder.append("Current balance: " + this.balance + "\n");
builder.append("Hand: " + this.hand + "\n");
builder.append("Hand value: " + this.hand.computeHandValue() + "\n");
String str = new String(builder);
return str;
}
}
......@@ -10,6 +10,10 @@ import java.util.Random;
public class Deck {
private List<Card> gameDeck;
public List<Card> getGameDeck() {
return gameDeck;
}
private Card popFromDeck() {
if (gameDeck.size() > 0) {
Random rnd = new Random();
......@@ -23,24 +27,21 @@ public class Deck {
private ArrayList<Card> construct32Deck() {
ArrayList<Card> list = new ArrayList<>(32);
for (int i = Arrays.asList(Card.getRANK_NAMES()).indexOf("As"); i <= Arrays.asList(Card.getRANK_NAMES())
.indexOf("As"); i++) {
for (int i = Card.getRANK_NAMES().indexOf("As"); i <= Card.getRANK_NAMES().indexOf("As"); i++) {
for (ColourSuit color : ColourSuit.values()) {
Card foo = new Card(color, i);
list.add(foo);
}
}
for (int i = Arrays.asList(Card.getRANK_NAMES()).indexOf("7"); i <= Arrays.asList(Card.getRANK_NAMES())
.indexOf("Valet"); i++) {
for (int i = Card.getRANK_NAMES().indexOf("7"); i <= Card.getRANK_NAMES().indexOf("Valet"); i++) {
for (ColourSuit color : ColourSuit.values()) {
Card foo = new Card(color, i);
list.add(foo);
}
}
for (int i = Arrays.asList(Card.getRANK_NAMES()).indexOf("Dame"); i <= Arrays.asList(Card.getRANK_NAMES())
.indexOf("Roi"); i++) {
for (int i = Card.getRANK_NAMES().indexOf("Dame"); i <= Card.getRANK_NAMES().indexOf("Roi"); i++) {
for (ColourSuit color : ColourSuit.values()) {
Card foo = new Card(color, i);
list.add(foo);
......@@ -52,16 +53,14 @@ public class Deck {
private ArrayList<Card> construct52Deck() {
ArrayList<Card> list = new ArrayList<>(52);
for (int i = Arrays.asList(Card.getRANK_NAMES()).indexOf("As"); i <= Arrays.asList(Card.getRANK_NAMES())
.indexOf("Valet"); i++) {
for (int i = Card.getRANK_NAMES().indexOf("As"); i <= Card.getRANK_NAMES().indexOf("Valet"); i++) {
for (ColourSuit color : ColourSuit.values()) {
Card foo = new Card(color, i);
list.add(foo);
}
}
for (int i = Arrays.asList(Card.getRANK_NAMES()).indexOf("Dame"); i <= Arrays.asList(Card.getRANK_NAMES())
.indexOf("Roi"); i++) {
for (int i = Card.getRANK_NAMES().indexOf("Dame"); i <= Card.getRANK_NAMES().indexOf("Roi"); i++) {
for (ColourSuit color : ColourSuit.values()) {
Card foo = new Card(color, i);
list.add(foo);
......@@ -75,7 +74,7 @@ public class Deck {
ArrayList<Card> list = construct52Deck();
for (int i = 0; i < 2; i++) {
Card foo = new Card(SpecialSuit.JOKER, Arrays.asList(Card.getRANK_NAMES()).indexOf("Joker"));
Card foo = new Card(SpecialSuit.JOKER, Card.getRANK_NAMES().indexOf("Joker"));
list.add(foo);
}
......@@ -86,7 +85,7 @@ public class Deck {
ArrayList<Card> list = construct52Deck();
for (int i = 0; i < 4; i++) {
Card foo = new Card(SpecialSuit.KNIGHT, Arrays.asList(Card.getRANK_NAMES()).indexOf("Cavalier"));
Card foo = new Card(SpecialSuit.KNIGHT, Card.getRANK_NAMES().indexOf("Cavalier"));
list.add(foo);
}
......@@ -97,7 +96,7 @@ public class Deck {
ArrayList<Card> list = construct56Deck();
for (int i = 0; i < 22; i++) {
Card foo = new Card(SpecialSuit.TRUMP, Arrays.asList(Card.getRANK_NAMES()).indexOf("Atout"));
Card foo = new Card(SpecialSuit.TRUMP, Card.getRANK_NAMES().indexOf("Atout"));
list.add(foo);
}
......@@ -130,20 +129,34 @@ public class Deck {
Collections.shuffle(this.gameDeck);
}
public static ArrayList<Deck> getPackOfCards(int nbDecks, int nbCards) {
public static ArrayList<Deck> createDecks(int nbDecks, int nbCards) {
if (nbDecks < 1) {
throw new RuntimeException("Number of decks has to be strictly positive and at least equal to 1");
}
ArrayList<Deck> pack = new ArrayList<>(nbDecks);
ArrayList<Deck> decks = new ArrayList<>(nbDecks);
for (int i = 0; i < nbDecks; i++) {
Deck bar = new Deck(nbCards);
bar.shuffleDeck();
pack.add(bar);
decks.add(bar);
}
return decks;
}
public Hand giveHand(int nbCards) {
Hand hand = new Hand(nbCards);
for (int i = 0; i < nbCards; i++) {
hand.addToHand(this.popFromDeck());
}
return hand;
}
return pack;
public Card removeFromDeck() {
return popFromDeck();
}
public Card[][] giveTwoHands() {
......@@ -182,8 +195,8 @@ public class Deck {
String name1[] = o1.toString().split(" ");
String name2[] = o2.toString().split(" ");
int lhs = Arrays.asList(Card.getRANK_NAMES()).indexOf(name1[0]);
int rhs = Arrays.asList(Card.getRANK_NAMES()).indexOf(name2[0]);
int lhs = Card.getRANK_NAMES().indexOf(name1[0]);
int rhs = Card.getRANK_NAMES().indexOf(name2[0]);
int diff_rank = lhs - rhs;
if (diff_rank != 0) {
......@@ -201,7 +214,7 @@ public class Deck {
System.out.println(gameDeck.toString());
}
public static void printPack(ArrayList<Deck> pack) {
public static void printDecks(List<Deck> pack) {
for (Deck d : pack) {
System.out.println("Tas de cartes");
System.out.println(d.toString());
......
package hepia;
import java.util.HashMap;
import java.util.Map;
public enum Game {
BLACKJACK;
static final int BLACKJACK_CARD_COUNT = 52;
// LUT for card weight in blackjack
public static Map<String, Integer> cardWeightBlackjack;
static {
cardWeightBlackjack = new HashMap<>();
cardWeightBlackjack.put("As", 1);
cardWeightBlackjack.put("2", 2);
cardWeightBlackjack.put("3", 3);
cardWeightBlackjack.put("4", 4);
cardWeightBlackjack.put("5", 5);
cardWeightBlackjack.put("6", 6);
cardWeightBlackjack.put("7", 7);
cardWeightBlackjack.put("8", 8);
cardWeightBlackjack.put("9", 9);
cardWeightBlackjack.put("10", 10);
cardWeightBlackjack.put("Valet", 10);
cardWeightBlackjack.put("Dame", 10);
cardWeightBlackjack.put("Roi", 10);
}
}
package hepia;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
public class GameManager {
static final int MIN_BET = 10;
private List<Deck> decks;
private List<HumanPlayer> humanPlayers;
private List<AIPlayer> aiPlayers;
private CroupierPlayer croupier;
private List<IPlayer> players;
private List<IPlayer> bustedPlayers;
private List<IPlayer> blackJackHands;
private List<Hand> bustedHands;
private Deck currentGame;
private Game game;
private static final Scanner scanner = new Scanner(System.in);
private void ensureValidPlayerCount(int nbPlayers) {
if (nbPlayers < 1 || nbPlayers > 7) {
throw new RuntimeException("Number of players has to be in the range [1, 7]");
}
}
private void ensureValidDeckCount(int nbDecks) {
if (nbDecks < 1 || nbDecks > 8) {
throw new RuntimeException("Number of decks has to be in the range [1, 8]");
}
}
private boolean ensureValidBetValue(int bet) {
if (bet < MIN_BET) {
System.out.println("The value of the bet has to be greater than or equal to 10.- CHF");
return false;
}
return true;
}
private void setBlackjackCardWeight(Card card) {
if (this.game == Game.BLACKJACK) {
card.setWeight(Game.cardWeightBlackjack.get(card.getRankName()));
}
}
private void askPlayersForBets(int nbPlayers) {
System.out.println();
for (int i = 0; i < nbPlayers; i++) {
int playerBet = 0;
do {
System.out.print("Player " + (i + 1) + ", please enter your bet: ");
playerBet = scanner.nextInt();
} while (!ensureValidBetValue(playerBet));
HumanPlayer player = new HumanPlayer(playerBet);
this.humanPlayers.add(player);
}
System.out.println();
}
private boolean playerHasBlackjack(IPlayer player) {
if (player.getHand().size() == 2 && player.getHand().computeHandValue() == 21) {
return true;
}
return false;
}
private void askPlayerToChangeWeight(HumanPlayer hp, Card card) {
boolean valid_input = false;
int choice = 0;
do {
System.out.println();
System.out.println("You have to select which weight to apply for this card: ");
System.out.println("\t1) 1\tHand value will be: " + hp.getHand().computeHandValue());
System.out.println("\t2) 11\tHand value will be: " + (hp.getHand().computeHandValue() + 10));
System.out.print("Please enter your choice: ");
choice = scanner.nextInt();
if (choice == 1 || choice == 2) {
valid_input = true;
} else {
System.out.println("Wrong input!");
}
} while (!valid_input);
switch (choice) {
case 1:
card.setWeight(1);
System.out.println("Your new hand value is: " + hp.getHand().computeHandValue());
break;
case 2:
card.setWeight(11);
System.out.println("Your new hand value is: " + hp.getHand().computeHandValue());
break;
default:
throw new RuntimeException("Error");
}
}
public void askPlayerForInsurance(HumanPlayer player) {
String input = "";
boolean inputCorrect = false;
do {
System.out.println();
System.out.println("Would you like to draw an insurance ? [y/n] ");
input = scanner.next();
switch (input) {
case "y":
inputCorrect = true;
player.setHasInsurance(true);
break;
case "n":
inputCorrect = true;
player.setHasInsurance(false);
break;
default:
break;
}
} while (!inputCorrect);
}
public void askPlayerForDoubleBet(HumanPlayer player) {
String input = "";
boolean inputCorrect = false;
do {
System.out.println();
System.out.println("Would you like to double your bet ? [y/n] ");
input = scanner.next();
switch (input) {
case "y":
inputCorrect = true;
player.setDoubledBet(true);
break;
case "n":
inputCorrect = true;
player.setDoubledBet(false);
break;
default:
break;
}
} while (!inputCorrect);
}
public boolean askPlayerForSplittingPair(IPlayer player) {
String input = "";
boolean inputCorrect = false;
do {
System.out.println();
System.out.println("Would you like to split your hand ? [y/n] ");
input = scanner.next();
switch (input) {
case "y":
inputCorrect = true;
player.splitHand();
return true;
case "n":
inputCorrect = true;
return false;
default:
break;
}
} while (!inputCorrect);
return false;
}
private boolean drawCardOrStop(HumanPlayer hp) {
String input = "";
boolean cardWasDrawn = false;
int nbCardsDrawnAfterDouble = 0;
do {
for (Card card : hp.getHand()) {
if (card.getRankName().equals("As") && hp.getHand().computeHandValue() + 10 <= 21) {
askPlayerToChangeWeight(hp, card);
if (hp.getHand().computeHandValue() == 21) {
return cardWasDrawn;
}
}
}
System.out.println();
System.out.println("Would you like to draw a new card ? [y/n] ");
input = scanner.next();
switch (input) {
case "y":
if (hp.hasDoubledBet()) {
nbCardsDrawnAfterDouble++;
}
cardWasDrawn = true;
Card drawnCard = this.currentGame.removeFromDeck();
hp.getHand().addToHand(drawnCard);
System.out.println("You've drawn: " + drawnCard.toString());
System.out.println("Your new hand value is: " + hp.getHand().computeHandValue());
if (nbCardsDrawnAfterDouble == 1) {
return cardWasDrawn = false;
}
return cardWasDrawn;
case "n":
return cardWasDrawn;
default:
break;
}
} while (true);
}
private void displayPlayerHand(IPlayer player) {
System.out.println();
if (player instanceof CroupierPlayer) {
System.out.println("Croupier's hand is: " + ((CroupierPlayer) player).getHand());
} else if (player instanceof HumanPlayer) {
System.out.println("Your current hand is: " + ((HumanPlayer) player).getHand());
} else if (player instanceof AIPlayer) {
System.out.println("AI's hand is: " + ((AIPlayer) player).getHand());
}
System.out.println("Its value is: " + player.getHand().computeHandValue());
}
public GameManager(
Game game,
int nbHumanPlayers,
int nbAIPlayers,
int nbDecks) {
ensureValidPlayerCount(nbHumanPlayers + nbAIPlayers);
ensureValidDeckCount(nbDecks);
this.game = game;
this.humanPlayers = new ArrayList<>(nbHumanPlayers);
this.aiPlayers = new ArrayList<>(nbAIPlayers);
this.players = new ArrayList<>(nbHumanPlayers + nbAIPlayers + 1);
this.bustedPlayers = new ArrayList<>();
this.blackJackHands = new ArrayList<>();
this.bustedHands = new ArrayList<>();
if (this.game == Game.BLACKJACK) {
this.decks = Deck.createDecks(nbDecks, Game.BLACKJACK_CARD_COUNT);
for (Deck deck : this.decks) {
for (Card card : deck.getGameDeck()) {
this.setBlackjackCardWeight(card);
}
}
}
initBets(nbHumanPlayers, nbAIPlayers);
}
private void initBets(int nbHumanPlayers, int nbAIPlayers) {
askPlayersForBets(nbHumanPlayers);
for (int i = 0; i < nbAIPlayers; i++) {
int aiBet = new Random().nextInt((100 - MIN_BET + 1) + MIN_BET);
AIPlayer ai = new AIPlayer(aiBet);
this.aiPlayers.add(ai);
}
this.croupier = new CroupierPlayer(0);
}
private void initHands() {
this.currentGame = this.decks.removeLast();
for (HumanPlayer humanPlayer : this.humanPlayers) {
humanPlayer.setHand(this.currentGame.giveHand(2));
this.players.add(humanPlayer);
}
for (AIPlayer aiPlayer : this.aiPlayers) {
aiPlayer.setHand(this.currentGame.giveHand(2));
this.players.add(aiPlayer);
}
this.croupier.setHand(this.currentGame.giveHand(1));
this.players.add(croupier);
}
private void round() {
// Humans' turns
for (HumanPlayer player : this.humanPlayers) {
System.out.println();
System.out.println(player);
boolean turnContinues = true;
if (player.getHand().isPair()) {
askPlayerForSplittingPair(player);
}
for (Card card : this.croupier.getHand()) {
if (card.getRankName().equals("As")) {
askPlayerForInsurance(player);
}
}
if (player.hasSplitHand()) {
for (int i = 0; i < player.getSplittedHand().size(); i++) {
System.out.println("======= Player's n°" + (i + 1) + " hand =======");
while (turnContinues) {
player.setHand(player.getSplittedHand().get(i));
displayPlayerHand(player);
turnContinues = drawCardOrStop(player);
if (player.getHand().computeHandValue() >= 21) {
if (player.getHand().computeHandValue() > 21) {
// this.bustedPlayers.add(player);
this.bustedHands.add(player.getHand());
}
break;
}
}
turnContinues = true;
}
} else {
askPlayerForDoubleBet(player);
while (turnContinues) {
displayPlayerHand(player);
turnContinues = drawCardOrStop(player);
if (player.getHand().computeHandValue() >= 21) {
if (player.getHand().computeHandValue() > 21) {
this.bustedPlayers.add(player);
// this.bustedHands.add(player.getHand());
}
break;
}
}
}
}
// Croupier's turn
System.out.println(this.croupier);
while (this.croupier.getHand().computeHandValue() < 17) {
displayPlayerHand(this.croupier);
for (Card card : this.croupier.getHand()) {
if (card.getRankName().equals("As")) {
if (this.croupier.getHand().computeHandValue() + 10 <= 21) {
System.out.println("Croupier assigned the value 11 to the ace");
card.setWeight(11);
if (this.croupier.getHand().computeHandValue() == 21) {
break;
}
}
}
}
System.out.println("Croupier drew a new card");
this.croupier.getHand().addToHand(this.currentGame.removeFromDeck());
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (this.croupier.getHand().computeHandValue() > 21) {
this.bustedPlayers.add(this.croupier);
}
displayPlayerHand(this.croupier);
}
private void compareHandsAssignGainsLosses(IPlayer player) {
int compare = player.getHand().compareTo(this.croupier.getHand());
switch (compare) {
case -1:
this.croupier.addToBalance(player.getBet());
break;
case 0:
player.addToBalance(player.getBet());
break;
case 1:
player.addToBalance(2 * player.getBet());
break;
default:
break;
}
}
private void computeGainsLosses() {
// Compute gains/losses per player
List<IPlayer> playersToPayout = new ArrayList<>(this.players);
// Sorting players
for (IPlayer player : this.players) {
if (playerHasBlackjack(player)) {
this.blackJackHands.add(player);
playersToPayout.remove(player);
}
if ((player instanceof HumanPlayer || player instanceof AIPlayer) && this.bustedPlayers.contains(player)) {
playersToPayout.remove(player);
}
}
for (IPlayer player : this.blackJackHands) {
player.addToBalance(1.5 * player.getBet() + player.getBet());
}
if (this.blackJackHands.contains(this.croupier)) {
// Paying out the insurances
for (IPlayer player : playersToPayout) {
if (!player.equals(this.croupier)) {
if (player.hasInsurance()) {
player.addToBalance(player.getInsuranceBet() * 2);
}
}
}
}
if (!this.bustedPlayers.contains(this.croupier)) {
for (IPlayer bustedPlayer : this.bustedPlayers) {
this.croupier.addToBalance(bustedPlayer.getBet());
}
for (IPlayer player : playersToPayout) {
if (!player.equals(this.croupier)) {
if (player.hasSplitHand()) {
for (Hand hand : player.getSplittedHand()) {
if (!this.bustedHands.contains(hand)) {
player.setHand(hand);
compareHandsAssignGainsLosses(player);
} else {
player.addToBalance((-1) * player.getBet());
this.croupier.addToBalance(player.getBet());
}
}
} else {
compareHandsAssignGainsLosses(player);
}
}
}
} else {
for (IPlayer player : playersToPayout) {
player.addToBalance(player.getBet());
}
}
}
public void runGame() {
if (this.game == Game.BLACKJACK) {
System.out.println("======= Giving out hands =======");
initHands();
System.out.println("Croupier drew: " + this.croupier.getHand());
System.out.println();
System.out.println("========= Start round ==========");
round();
System.out.println();
System.out.println();
System.out.println("=========== Results ============");
computeGainsLosses();
int player_counter = 0;
for (IPlayer player : this.players) {
System.out.println();
System.out.println("======= Player " + (player_counter + 1) + " =======");
if (player.hasSplitHand()) {
for (int i = 0; i < player.getSplittedHand().size(); i++) {
System.out.println("======= Player's n°" + (i + 1) + " hand =======");
player.setHand(player.getSplittedHand().get(i));
System.out.println(player.toString());
}
} else {
System.out.println(player.toString());
}
player_counter++;
}
}
}
}
package hepia;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Hand
*/
public class Hand implements Comparable<Hand>, Iterable<Card> {
private List<Card> hand;
public boolean isPair() {
if (this.hand.size() == 2) {
return (this.hand.get(0).getWeight() == this.hand.get(1).getWeight())
&& !this.hand.get(0).getRankName().equals("As");
}
return false;
}
public Hand(int nbCards) {
this.hand = new ArrayList<>(nbCards);
}
public Hand(Card card) {
this.hand = new ArrayList<>();
this.hand.add(card);
}
public Card getCardFromHand(int idx) {
return this.hand.get(idx);
}
public void addToHand(Card card) {
this.hand.add(card);
}
public int computeHandValue() {
return this.hand.stream().mapToInt(Card::getWeight).sum();
}
public int size() {
return this.hand.size();
}
@Override
public int compareTo(Hand arg0) {
int lhs = this.computeHandValue();
int rhs = arg0.computeHandValue();
return Integer.compare(lhs, rhs);
}
@Override
public Iterator<Card> iterator() {
return this.hand.iterator();
}
@Override
public String toString() {
return this.hand.toString();
}
}
package hepia;
import java.util.ArrayList;
import java.util.List;
/**
* HumanPlayer
*/
public class HumanPlayer implements IPlayer {
private int bet;
private Hand hand;
private List<Hand> splittedHand;
private double balance;
private boolean hasInsurance;
private int insuranceBet;
private boolean hasDoubledBet;
@Override
public boolean hasSplitHand() {
if (splittedHand != null) {
return true;
}
return false;
}
@Override
public void splitHand() {
splittedHand = new ArrayList<>();
for (int i = 0; i < hand.size(); i++) {
splittedHand.add(new Hand(this.hand.getCardFromHand(i)));
}
this.bet *= 2;
}
@Override
public List<Hand> getSplittedHand() {
return splittedHand;
}
@Override
public boolean hasDoubledBet() {
return hasDoubledBet;
}
public void setDoubledBet(boolean doubledBet) {
if (doubledBet) {
this.bet *= 2;
}
this.hasDoubledBet = doubledBet;
}
@Override
public int getInsuranceBet() {
return insuranceBet;
}
@Override
public boolean hasInsurance() {
return hasInsurance;
}
public void setHasInsurance(boolean hasInsurance) {
if (hasInsurance) {
insuranceBet = this.bet / 2;
}
this.hasInsurance = hasInsurance;
}
@Override
public void addToBalance(double amount) {
this.balance += amount;
}
@Override
public double getBalance() {
return this.balance;
}
@Override
public void setHand(Hand hand) {
this.hand = hand;
}
@Override
public Hand getHand() {
return hand;
}
public HumanPlayer(int bet) {
placeBet(bet);
this.balance = 0.0;
}
@Override
public void placeBet(int valueOfBet) {
this.bet = valueOfBet;
}
@Override
public int getBet() {
return this.bet;
}
@Override
public void receiveHand(Hand hand) {
this.hand = hand;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("========= Human Player =========\n");
builder.append("Value of bet: " + this.bet + "\n");
builder.append("Current balance: " + this.balance + "\n");
builder.append("Hand: " + this.hand + "\n");
builder.append("Hand value: " + this.hand.computeHandValue() + "\n");
String str = new String(builder);
return str;
}
}
package hepia;
import java.util.List;
public interface IPlayer {
void placeBet(int valueOfBet);
boolean hasSplitHand();
boolean hasInsurance();
List<Hand> getSplittedHand();
void splitHand();
boolean hasDoubledBet();
int getInsuranceBet();
void addToBalance(double amount);
double getBalance();
int getBet();
Hand getHand();
public void setHand(Hand hand);
void receiveHand(Hand hand);
@Override
String toString();
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment