From d196e7c2a1b7677bc42ee3047cdaa17a2b92cba9 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 13:36:19 -0400 Subject: [PATCH 01/73] puml file --- Casino.puml | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 170 insertions(+) create mode 100644 Casino.puml diff --git a/Casino.puml b/Casino.puml new file mode 100644 index 000000000..95615d589 --- /dev/null +++ b/Casino.puml @@ -0,0 +1,170 @@ +@startuml +'https://plantuml.com/sequence-diagram + +class playerClass { +private playerName; +private final playerID; +private wallet; +private chipBalance; + +get/setter name; +get ID; +get chipBalance; +get wallet; +addToWallet; + +wageMoney; +cashOut; +getMoreChips; +} + +interface Game { +playGame; +checkWinner; +} + +interface gamblingGame { +addToPot; +winPot; +} + +interface gamblingPlayer { +wageMoney; +cashOut; +getMoreChips; +} + +abstract class cardGame { +private stack deckOfCards; +private stack discardPile; +private ArrayList playerHand; +private ArrayList dealerHand; + +playGame; +makeDeck; +shuffleDeck; +dealCards; +discardPile; +} + +abstract class diceGame { +private int totalNumOfDice; +ArrayList playerDiceHand; + +playGame; +checkWinner; +addToPot; +winPot; +rollDice; +} + +class chipMoneyExchange { +chipsToMoney; +moneyToChips; +} + +class goFish { +ArrayList playerHand; +ArrayList dealerHand; +int numOfPlayerMatches; +int numOfDealerMatches; + +doYouHaveCard; +removeCardFromHand; +addToPlayerMatches; +addToDealerMatches; +checkWinner; +} + +class blackJack { +ArrayList playerHand; +ArrayList playerSplitHand; +ArrayList dealerHand; +ArrayList dealerSplitHand; +int playerTotal; +int dealerTotal; +int sizeOfPot; + +addToPot; +winPot; +checkWinner; +splitHand; +hitMe; +(boolean)didIBust; +} + +class craps { +String stateOfGame(passOrNot); +int currentRound; +} + +class extraDiceGame { +ArrayList dealerDiceHand; +int playerCount; +int dealerCount; + +countMatches; +checkWinner; +holdDice(int... index); +} + +class userWarehouse { +HashSet currentPlayers; + +addPlayer; +removePlayer; +howManyPlayers; +} + +class creatorOfAllThings { +createUser; +createCard; +createDice; +} + +class cardMaker { +private String nameOfCard; +private String suitOfCard; +private int valueOfCard; +} + +class Display { +enterCasinoScreen; +chipMoneyExchangeScreen; +chooseGameScreen; +goFish(all the screens); +blackJack(all the screens); +craps(all the screens); +extraDiceGame(all the screens); +} + + +class mainCasino { +runCasino; +} + +diceGame <|--- craps +diceGame <|--- extraDiceGame + +cardGame <|--- goFish +cardGame <|--- blackJack + +Game <|--- gamblingGame +Game <|--- goFish + +gamblingGame <|--- blackJack +gamblingGame <|--- diceGame + +gamblingPlayer <|-- playerClass + +Game <|-- cardGame + + + +'Alice -> Bob: Authentication Request +'Bob --> Alice: Authentication Response +' +'Alice -> Bob: Another authentication Request +'Alice <-- Bob: another authentication Response + +@enduml \ No newline at end of file From 1d82d4b71eefc26a8c08e8118f5dcedb465e688e Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 13:57:08 -0400 Subject: [PATCH 02/73] updated UML --- Casino.puml | 73 +++++++++++++++++++++++++++++------------------------ 1 file changed, 40 insertions(+), 33 deletions(-) diff --git a/Casino.puml b/Casino.puml index 95615d589..8a2840529 100644 --- a/Casino.puml +++ b/Casino.puml @@ -1,16 +1,16 @@ @startuml 'https://plantuml.com/sequence-diagram -class playerClass { -private playerName; -private final playerID; -private wallet; -private chipBalance; +class PlayerClass { +private String playerName; +private final int playerID; +private int wallet; +private int chipBalance; get/setter name; get ID; -get chipBalance; -get wallet; +get/set chipBalance; +get/set wallet; addToWallet; wageMoney; @@ -23,31 +23,32 @@ playGame; checkWinner; } -interface gamblingGame { +interface GamblingGame { addToPot; winPot; } -interface gamblingPlayer { +interface GamblingPlayer { wageMoney; cashOut; getMoreChips; } -abstract class cardGame { -private stack deckOfCards; -private stack discardPile; +abstract class CardGame { +private ArrayList deck; +private ArrayList discardPile; private ArrayList playerHand; private ArrayList dealerHand; playGame; +checkWinner; makeDeck; shuffleDeck; dealCards; discardPile; } -abstract class diceGame { +abstract class DiceGame { private int totalNumOfDice; ArrayList playerDiceHand; @@ -58,12 +59,12 @@ winPot; rollDice; } -class chipMoneyExchange { +class ChipMoneyExchange { chipsToMoney; moneyToChips; } -class goFish { +class GoFish { ArrayList playerHand; ArrayList dealerHand; int numOfPlayerMatches; @@ -76,7 +77,7 @@ addToDealerMatches; checkWinner; } -class blackJack { +class BlackJack { ArrayList playerHand; ArrayList playerSplitHand; ArrayList dealerHand; @@ -93,12 +94,12 @@ hitMe; (boolean)didIBust; } -class craps { +class Craps { String stateOfGame(passOrNot); int currentRound; } -class extraDiceGame { +class ExtraDiceGame { ArrayList dealerDiceHand; int playerCount; int dealerCount; @@ -108,7 +109,7 @@ checkWinner; holdDice(int... index); } -class userWarehouse { +class PlayerWarehouse { HashSet currentPlayers; addPlayer; @@ -116,13 +117,19 @@ removePlayer; howManyPlayers; } -class creatorOfAllThings { -createUser; +class PlayerFactory { +createPlayer; +} + +class CardFactory { createCard; +} + +class DiceFactory { createDice; } -class cardMaker { +class CardMaker { private String nameOfCard; private String suitOfCard; private int valueOfCard; @@ -139,25 +146,25 @@ extraDiceGame(all the screens); } -class mainCasino { +class MainCasino { runCasino; } -diceGame <|--- craps -diceGame <|--- extraDiceGame +DiceGame <|--- Craps +DiceGame <|--- ExtraDiceGame + +CardGame <|--- GoFish +CardGame <|--- BlackJack -cardGame <|--- goFish -cardGame <|--- blackJack +Game <|--- GamblingGame -Game <|--- gamblingGame -Game <|--- goFish -gamblingGame <|--- blackJack -gamblingGame <|--- diceGame +GamblingGame <|--- BlackJack +GamblingGame <|--- DiceGame -gamblingPlayer <|-- playerClass +GamblingPlayer <|-- PlayerClass -Game <|-- cardGame +Game <|-- CardGame From d04315dc1217f0a77bb21a5f509691d72c74de92 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 15:41:05 -0400 Subject: [PATCH 03/73] GamblingGame interface made. DiceGame abstract class made --- Casino.puml | 1 + .../zipcoder/casino/utilities/DiceGame.java | 29 +++++++++++++++++++ .../casino/utilities/GamblingGame.java | 7 +++++ 3 files changed, 37 insertions(+) create mode 100644 src/main/java/io/zipcoder/casino/utilities/DiceGame.java create mode 100644 src/main/java/io/zipcoder/casino/utilities/GamblingGame.java diff --git a/Casino.puml b/Casino.puml index 8a2840529..d35712ee9 100644 --- a/Casino.puml +++ b/Casino.puml @@ -51,6 +51,7 @@ discardPile; abstract class DiceGame { private int totalNumOfDice; ArrayList playerDiceHand; +int sizeOfPot; playGame; checkWinner; diff --git a/src/main/java/io/zipcoder/casino/utilities/DiceGame.java b/src/main/java/io/zipcoder/casino/utilities/DiceGame.java new file mode 100644 index 000000000..84b59428b --- /dev/null +++ b/src/main/java/io/zipcoder/casino/utilities/DiceGame.java @@ -0,0 +1,29 @@ +package io.zipcoder.casino.utilities; + +import java.util.ArrayList; + +public abstract class DiceGame implements GamblingGame { + private int totalNumOfDice; + ArrayList playerDiceHand; + int pot = 0; + + public void addToPot(int numOfChips) { + pot += numOfChips; + } + + public void clearPot() { + pot = 0; + } + + public int winsPot() { + return pot; + } + + public boolean checkWinner() { + return false; + } + + public int rollDice() { + return (int) (Math.random() * 6) + 1; + } +} diff --git a/src/main/java/io/zipcoder/casino/utilities/GamblingGame.java b/src/main/java/io/zipcoder/casino/utilities/GamblingGame.java new file mode 100644 index 000000000..9d0070e90 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/utilities/GamblingGame.java @@ -0,0 +1,7 @@ +package io.zipcoder.casino.utilities; + +public interface GamblingGame { + + void addToPot(); + void winPot(); +} From 369dc2e286dcb2ae8af9824e9f7dd8df7d374662 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 15:54:28 -0400 Subject: [PATCH 04/73] dice tests written for current methods --- .../casino/{utilities => }/DiceGame.java | 8 +-- .../casino/{utilities => }/GamblingGame.java | 4 +- .../io/zipcoder/casino/MostOfAKindGame.java | 13 ++++ .../io/zipcoder/casino/DiceGameTests.java | 61 +++++++++++++++++++ 4 files changed, 79 insertions(+), 7 deletions(-) rename src/main/java/io/zipcoder/casino/{utilities => }/DiceGame.java (74%) rename src/main/java/io/zipcoder/casino/{utilities => }/GamblingGame.java (50%) create mode 100644 src/main/java/io/zipcoder/casino/MostOfAKindGame.java create mode 100644 src/test/java/io/zipcoder/casino/DiceGameTests.java diff --git a/src/main/java/io/zipcoder/casino/utilities/DiceGame.java b/src/main/java/io/zipcoder/casino/DiceGame.java similarity index 74% rename from src/main/java/io/zipcoder/casino/utilities/DiceGame.java rename to src/main/java/io/zipcoder/casino/DiceGame.java index 84b59428b..2de626c77 100644 --- a/src/main/java/io/zipcoder/casino/utilities/DiceGame.java +++ b/src/main/java/io/zipcoder/casino/DiceGame.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino.utilities; +package io.zipcoder.casino; import java.util.ArrayList; @@ -7,15 +7,13 @@ public abstract class DiceGame implements GamblingGame { ArrayList playerDiceHand; int pot = 0; - public void addToPot(int numOfChips) { - pot += numOfChips; - } + public void addToPot() {} public void clearPot() { pot = 0; } - public int winsPot() { + public int getPot() { return pot; } diff --git a/src/main/java/io/zipcoder/casino/utilities/GamblingGame.java b/src/main/java/io/zipcoder/casino/GamblingGame.java similarity index 50% rename from src/main/java/io/zipcoder/casino/utilities/GamblingGame.java rename to src/main/java/io/zipcoder/casino/GamblingGame.java index 9d0070e90..59cdef6aa 100644 --- a/src/main/java/io/zipcoder/casino/utilities/GamblingGame.java +++ b/src/main/java/io/zipcoder/casino/GamblingGame.java @@ -1,7 +1,7 @@ -package io.zipcoder.casino.utilities; +package io.zipcoder.casino; public interface GamblingGame { void addToPot(); - void winPot(); + int getPot(); } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java new file mode 100644 index 000000000..3999a2783 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -0,0 +1,13 @@ +package io.zipcoder.casino; + +import io.zipcoder.casino.DiceGame; + +public class MostOfAKindGame extends DiceGame { + public void addToPot(int numOfChips) { + pot += numOfChips; + } + + public int getPot() { + return pot; + } +} diff --git a/src/test/java/io/zipcoder/casino/DiceGameTests.java b/src/test/java/io/zipcoder/casino/DiceGameTests.java new file mode 100644 index 000000000..0b97fd776 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/DiceGameTests.java @@ -0,0 +1,61 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +public class DiceGameTests { + + @Test + public void getPot() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + int expected = 0; + + //When + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void addToPot() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + int expected = 5; + + //When + yahtzee.addToPot(5); + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void clearPot() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + int expected = 0; + yahtzee.addToPot(7); + yahtzee.clearPot(); + + //When + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void rollDice() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + + //When + int result = yahtzee.rollDice(); + + //Then + Assert.assertTrue(result > 0 && result < 7); + } +} From 3b9ad1ad18d0ffcdb68fdd764ec1995e6ac2120a Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 16:05:23 -0400 Subject: [PATCH 05/73] added craps class and tests for methods of MostOfAKind and Craps --- src/main/java/io/zipcoder/casino/Craps.java | 14 ++++ .../{DiceGameTests.java => CrapsTest.java} | 15 +++- .../io/zipcoder/casino/MostOfAKindTests.java | 74 +++++++++++++++++++ 3 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 src/main/java/io/zipcoder/casino/Craps.java rename src/test/java/io/zipcoder/casino/{DiceGameTests.java => CrapsTest.java} (79%) create mode 100644 src/test/java/io/zipcoder/casino/MostOfAKindTests.java diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java new file mode 100644 index 000000000..943d048e9 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -0,0 +1,14 @@ +package io.zipcoder.casino; + +public class Craps extends DiceGame { + int gameRound; + String passOrNot = ""; + + public void addToPot(int numOfChips) { + pot += numOfChips; + } + + public int getPot() { + return pot; + } +} diff --git a/src/test/java/io/zipcoder/casino/DiceGameTests.java b/src/test/java/io/zipcoder/casino/CrapsTest.java similarity index 79% rename from src/test/java/io/zipcoder/casino/DiceGameTests.java rename to src/test/java/io/zipcoder/casino/CrapsTest.java index 0b97fd776..27e664dd7 100644 --- a/src/test/java/io/zipcoder/casino/DiceGameTests.java +++ b/src/test/java/io/zipcoder/casino/CrapsTest.java @@ -3,7 +3,7 @@ import org.junit.Assert; import org.junit.Test; -public class DiceGameTests { +public class CrapsTest { @Test public void getPot() { @@ -58,4 +58,17 @@ public void rollDice() { //Then Assert.assertTrue(result > 0 && result < 7); } + + @Test + public void checkWinner() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + boolean expected = false; + + //When + boolean actual = yahtzee.checkWinner(); + + //Then + Assert.assertEquals(expected, actual); + } } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java new file mode 100644 index 000000000..ec779f3e7 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -0,0 +1,74 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +public class MostOfAKindTests { + + @Test + public void getPot() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + int expected = 0; + + //When + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void addToPot() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + int expected = 5; + + //When + yahtzee.addToPot(5); + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void clearPot() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + int expected = 0; + yahtzee.addToPot(7); + yahtzee.clearPot(); + + //When + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void rollDice() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + + //When + int result = yahtzee.rollDice(); + + //Then + Assert.assertTrue(result > 0 && result < 7); + } + + @Test + public void checkWinner() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + boolean expected = false; + + //When + boolean actual = yahtzee.checkWinner(); + + //Then + Assert.assertEquals(expected, actual); + } +} From 66721935b9a210918d15a4f80c1998fc3309da84 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 16:06:52 -0400 Subject: [PATCH 06/73] added fields to MostOfAKind --- src/main/java/io/zipcoder/casino/MostOfAKindGame.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 3999a2783..3587b93dc 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -2,7 +2,13 @@ import io.zipcoder.casino.DiceGame; +import java.util.ArrayList; + public class MostOfAKindGame extends DiceGame { + ArrayList dealerHand; + int dealerCount; + int playerCount; + public void addToPot(int numOfChips) { pot += numOfChips; } From aafde5418d70fac3937a7d6aa56b306907f7623d Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 16:26:10 -0400 Subject: [PATCH 07/73] updated uml. added main class. Casino class has run method --- Casino.puml | 7 ++++--- src/main/java/io/zipcoder/casino/Casino.java | 3 +++ src/main/java/io/zipcoder/casino/Main.java | 9 +++++++++ 3 files changed, 16 insertions(+), 3 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/Main.java diff --git a/Casino.puml b/Casino.puml index d35712ee9..404067bdb 100644 --- a/Casino.puml +++ b/Casino.puml @@ -126,9 +126,6 @@ class CardFactory { createCard; } -class DiceFactory { -createDice; -} class CardMaker { private String nameOfCard; @@ -146,6 +143,10 @@ craps(all the screens); extraDiceGame(all the screens); } +class cardWarehouse { +ArrayList deckOfCards; +} + class MainCasino { runCasino; diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 86953f995..7b7187539 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -5,4 +5,7 @@ public class Casino { public static void main(String[] args) { // write your tests before you start } + + public void run() { + } } diff --git a/src/main/java/io/zipcoder/casino/Main.java b/src/main/java/io/zipcoder/casino/Main.java new file mode 100644 index 000000000..70e37beb9 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Main.java @@ -0,0 +1,9 @@ +package io.zipcoder.casino; + +public class Main { + + public void main (String[] args) { + Casino casino = new Casino(); + casino.run(); + } +} From b4685c3726ccb4e8826cfed30c147199e3dd480e Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 16:40:45 -0400 Subject: [PATCH 08/73] added checkwinner boolean --- .../io/zipcoder/casino/MostOfAKindGame.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 3587b93dc..2b8cf7103 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -16,4 +16,22 @@ public void addToPot(int numOfChips) { public int getPot() { return pot; } + + public int getDealerCount() { + return dealerCount; + } + + public int getPlayerCount() { + return playerCount; + } + + public boolean checkWinner() { + boolean doIWin = false; + if (getDealerCount() > getPlayerCount()) { + return doIWin; + } else if (getPlayerCount() > getDealerCount()) { + doIWin = true; + } + return doIWin; + } } From 16a6c4b4d3decb1294054b9eb9e2acc66cbe12c1 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 17:21:16 -0400 Subject: [PATCH 09/73] mostofakind tests updated. mostofakind bug fixes. Chipmoneyexchange written. ChipMoneyExchange tests written and pass --- .../io/zipcoder/casino/ChipMoneyExchange.java | 13 +++++++ .../io/zipcoder/casino/MostOfAKindGame.java | 14 ++++++-- .../casino/ChipMoneyExchangeTest.java | 33 +++++++++++++++++ .../io/zipcoder/casino/MostOfAKindTests.java | 36 +++++++++++++++++-- 4 files changed, 90 insertions(+), 6 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/ChipMoneyExchange.java create mode 100644 src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java diff --git a/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java b/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java new file mode 100644 index 000000000..54e935b12 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java @@ -0,0 +1,13 @@ +package io.zipcoder.casino; + +public class ChipMoneyExchange { + + + public int moneyToChips(int cash) { + return cash; + } + + public int chipsToMoney(int numOfChips) { + return numOfChips; + } +} diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 2b8cf7103..901701101 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -27,11 +27,19 @@ public int getPlayerCount() { public boolean checkWinner() { boolean doIWin = false; - if (getDealerCount() > getPlayerCount()) { - return doIWin; - } else if (getPlayerCount() > getDealerCount()) { + if (getPlayerCount() > getDealerCount()) { doIWin = true; + } else if (getDealerCount() > getPlayerCount()) { + doIWin = false; } return doIWin; } + + public void addToPlayerCount(int numOfSameNum) { + playerCount += numOfSameNum; + } + + public void addToDealerCount(int numOfSameNum) { + dealerCount += numOfSameNum; + } } diff --git a/src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java b/src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java new file mode 100644 index 000000000..7d99df8bd --- /dev/null +++ b/src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java @@ -0,0 +1,33 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +public class ChipMoneyExchangeTest { + + @Test + public void chipsToMoney() { + //Given + ChipMoneyExchange exchange = new ChipMoneyExchange(); + int expected = 10; + + //When + int actual = exchange.chipsToMoney(10); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void moneyToChips() { + //Given + ChipMoneyExchange exchange = new ChipMoneyExchange(); + int expected = 12; + + //When + int actual = exchange.moneyToChips(12); + + //Then + Assert.assertEquals(expected, actual); + } +} diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index ec779f3e7..8324f286d 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -60,15 +60,45 @@ public void rollDice() { } @Test - public void checkWinner() { + public void addToPlayerCount() { //Given MostOfAKindGame yahtzee = new MostOfAKindGame(); - boolean expected = false; + yahtzee.addToPlayerCount(3); + int expected = 3; //When - boolean actual = yahtzee.checkWinner(); + int actual = yahtzee.getPlayerCount(); //Then Assert.assertEquals(expected, actual); } + + @Test + public void checkWinnerDealer() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.addToPlayerCount(3); + yahtzee.addToDealerCount(4); + + //When + boolean actual = yahtzee.checkWinner(); + + //Then + Assert.assertFalse(actual); + } + + @Test + public void checkWinnerPlayer() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.addToPlayerCount(4); + yahtzee.addToDealerCount(2); + + //When + boolean actual = yahtzee.checkWinner(); + + //Then + Assert.assertTrue(actual); + } + } From 09e5a146cc6d9bfcf52e9a4ff4116b101f3aa44c Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Mon, 15 Mar 2021 18:46:19 -0400 Subject: [PATCH 10/73] Game CardGame and Card classes complete --- src/main/java/io/zipcoder/casino/Card.java | 28 ++++ .../java/io/zipcoder/casino/CardGame.java | 155 ++++++++++++++++++ src/main/java/io/zipcoder/casino/Game.java | 8 + 3 files changed, 191 insertions(+) create mode 100644 src/main/java/io/zipcoder/casino/Card.java create mode 100644 src/main/java/io/zipcoder/casino/CardGame.java create mode 100644 src/main/java/io/zipcoder/casino/Game.java diff --git a/src/main/java/io/zipcoder/casino/Card.java b/src/main/java/io/zipcoder/casino/Card.java new file mode 100644 index 000000000..921545626 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Card.java @@ -0,0 +1,28 @@ +package io.zipcoder.casino; + +public class Card { + //value from ace to king + private String cardName; + //Spade, Diamond, Heart, Clubs + private String cardSuit; + //value = name from 2-10. Jack queen and king are also ten, with ace being 1 or 11 in blackjack. + private Integer cardValue; + + public Card(String name, String suit, Integer value){ + cardName=name; + cardSuit=suit; + cardValue=value; + } + + private String getCardName(){ + return cardName; + } + + private Integer getValue(){ + return cardValue; + } + + private String getCardSuit(){ + return cardSuit; + } +} diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java new file mode 100644 index 000000000..68331736f --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CardGame.java @@ -0,0 +1,155 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +abstract class CardGame implements Game { + private List deck=new ArrayList(); + private ListdiscardPile=new ArrayList(); + private List playerHand=new ArrayList(); + private List dealerHand=new ArrayList(); + private Card AceOfSpades=new Card("A", "Spades", 11); + private Card TwoOfSpades=new Card("2", "Spades", 2); + private Card ThreeOfSpades=new Card("3", "Spades", 3); + private Card FourOfSpades=new Card("4", "Spades", 4); + private Card FiveOfSpades=new Card("5", "Spades", 5); + private Card SixOfSpades=new Card("6", "Spades", 6); + private Card SevenOfSpades=new Card("7", "Spades", 7); + private Card EightOfSpades=new Card("8", "Spades", 8); + private Card NineOfSpades=new Card("9", "Spades", 9); + private Card TenOfSpades=new Card("10", "Spades", 10); + private Card JackOfSpades=new Card("J", "Spades", 10); + private Card QueenOfSpades=new Card("Q", "Spades", 10); + private Card KingOfSpades=new Card("K", "Spades", 10); + + private Card AceOfClubs=new Card("A", "Clubs", 11); + private Card TwoOfClubs=new Card("2", "Clubs", 2); + private Card ThreeOfClubs=new Card("3", "Clubs", 3); + private Card FourOfClubs=new Card("4", "Clubs", 4); + private Card FiveOfClubs=new Card("5", "Clubs", 5); + private Card SixOfClubs=new Card("6", "Clubs", 6); + private Card SevenOfClubs=new Card("7", "Clubs", 7); + private Card EightOfClubs=new Card("8", "Clubs", 8); + private Card NineOfClubs=new Card("9", "Clubs", 9); + private Card TenOfClubs=new Card("10", "Clubs", 10); + private Card JackOfClubs=new Card("J", "Clubs", 10); + private Card QueenOfClubs=new Card("Q", "Clubs", 10); + private Card KingOfClubs=new Card("K", "Clubs", 10); + + private Card AceOfDiamonds=new Card("A", "Diamonds", 11); + private Card TwoOfDiamonds=new Card("2", "Diamonds", 2); + private Card ThreeOfDiamonds=new Card("3", "Diamonds", 3); + private Card FourOfDiamonds=new Card("4", "Diamonds", 4); + private Card FiveOfDiamonds=new Card("5", "Diamonds", 5); + private Card SixOfDiamonds=new Card("6", "Diamonds", 6); + private Card SevenOfDiamonds=new Card("7", "Diamonds", 7); + private Card EightOfDiamonds=new Card("8", "Diamonds", 8); + private Card NineOfDiamonds=new Card("9", "Diamonds", 9); + private Card TenOfDiamonds=new Card("10", "Diamonds", 10); + private Card JackOfDiamonds=new Card("J", "Diamonds", 10); + private Card QueenOfDiamonds=new Card("Q", "Diamonds", 10); + private Card KingOfDiamonds=new Card("K", "Diamonds", 10); + + private Card AceOfHearts=new Card("A", "Hearts", 11); + private Card TwoOfHearts=new Card("2", "Hearts", 2); + private Card ThreeOfHearts=new Card("3", "Hearts", 3); + private Card FourOfHearts=new Card("4", "Hearts", 4); + private Card FiveOfHearts=new Card("5", "Hearts", 5); + private Card SixOfHearts=new Card("6", "Hearts", 6); + private Card SevenOfHearts=new Card("7", "Hearts", 7); + private Card EightOfHearts=new Card("8", "Hearts", 8); + private Card NineOfHearts=new Card("9", "Hearts", 9); + private Card TenOfHearts=new Card("10", "Hearts", 10); + private Card JackOfHearts=new Card("J", "Hearts", 10); + private Card QueenOfHearts=new Card("Q", "Hearts", 10); + private Card KingOfHearts=new Card("K", "Hearts", 10); + + + + + + + //method to set deck to new deck. + //clears out deck then fills with all 52 cards. + public void makeDeck(){ + if (deck!=null){deck.clear();} + deck.add(AceOfSpades); + deck.add(TwoOfSpades); + deck.add(ThreeOfSpades); + deck.add(FourOfSpades); + deck.add(FiveOfSpades); + deck.add(SixOfSpades); + deck.add(SevenOfSpades); + deck.add(EightOfSpades); + deck.add(NineOfSpades); + deck.add(TenOfSpades); + deck.add(JackOfSpades); + deck.add(QueenOfSpades); + deck.add(KingOfSpades); + + deck.add(AceOfClubs); + deck.add(TwoOfClubs); + deck.add(ThreeOfClubs); + deck.add(FourOfClubs); + deck.add(FiveOfClubs); + deck.add(SixOfClubs); + deck.add(SevenOfClubs); + deck.add(EightOfClubs); + deck.add(NineOfClubs); + deck.add(TenOfClubs); + deck.add(JackOfClubs); + deck.add(QueenOfClubs); + deck.add(KingOfClubs); + + deck.add(AceOfDiamonds); + deck.add(TwoOfDiamonds); + deck.add(ThreeOfDiamonds); + deck.add(FourOfDiamonds); + deck.add(FiveOfDiamonds); + deck.add(SixOfDiamonds); + deck.add(SevenOfDiamonds); + deck.add(EightOfDiamonds); + deck.add(NineOfDiamonds); + deck.add(TenOfDiamonds); + deck.add(JackOfDiamonds); + deck.add(QueenOfDiamonds); + deck.add(KingOfDiamonds); + + deck.add(AceOfHearts); + deck.add(TwoOfHearts); + deck.add(ThreeOfHearts); + deck.add(FourOfHearts); + deck.add(FiveOfHearts); + deck.add(SixOfHearts); + deck.add(SevenOfHearts); + deck.add(EightOfHearts); + deck.add(NineOfHearts); + deck.add(TenOfHearts); + deck.add(JackOfHearts); + deck.add(QueenOfHearts); + deck.add(KingOfHearts); + + }; + + //shuffles a chosen arraylist. + public void shuffleDeck(){ + Collections.shuffle(deck); + }; + + //I want this method to pick a random card from the deck and deal it to another arrayList. + public void dealCards(int whichPlayer){ + if(whichPlayer==1){ + playerHand.add(deck.get(0)); + deck.remove(0); + }else if(whichPlayer==2){ + dealerHand.add(deck.get(0)); + deck.remove(0); + }else System.out.println("Pick player one or two, please."); + + }; + + //temporary, I don't actually know what this is for as of yet. + //public void discardPileReshuffle(){}; +} diff --git a/src/main/java/io/zipcoder/casino/Game.java b/src/main/java/io/zipcoder/casino/Game.java new file mode 100644 index 000000000..f40926cc6 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Game.java @@ -0,0 +1,8 @@ +package io.zipcoder.casino; + +public interface Game { + public void playGame(); + + + public boolean checkWinner(); +} From 6a915ebda3c9badf4220f60f43eed65efc47b2bc Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Mon, 15 Mar 2021 18:53:23 -0400 Subject: [PATCH 11/73] created player, playerwarehouse, playerfactory --- pom.xml | 12 ++ .../java/io/zipcoder/casino/CardFactory.java | 8 + .../io/zipcoder/casino/GamblingPlayer.java | 8 + src/main/java/io/zipcoder/casino/Player.java | 67 ++++++ .../io/zipcoder/casino/PlayerFactory.java | 8 + .../io/zipcoder/casino/PlayerWarehouse.java | 24 +++ .../io/zipcoder/casino/PlayerFactoryTest.java | 203 ++++++++++++++++++ .../java/io/zipcoder/casino/PlayerTest.java | 196 +++++++++++++++++ .../zipcoder/casino/PlayerWarehouseTest.java | 71 ++++++ 9 files changed, 597 insertions(+) create mode 100644 src/main/java/io/zipcoder/casino/CardFactory.java create mode 100644 src/main/java/io/zipcoder/casino/GamblingPlayer.java create mode 100644 src/main/java/io/zipcoder/casino/Player.java create mode 100644 src/main/java/io/zipcoder/casino/PlayerFactory.java create mode 100644 src/main/java/io/zipcoder/casino/PlayerWarehouse.java create mode 100644 src/test/java/io/zipcoder/casino/PlayerFactoryTest.java create mode 100644 src/test/java/io/zipcoder/casino/PlayerTest.java create mode 100644 src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java diff --git a/pom.xml b/pom.xml index c6ec0cc8b..a1b0ae8dc 100644 --- a/pom.xml +++ b/pom.xml @@ -7,6 +7,18 @@ io.zipcoder casino 1.0-SNAPSHOT + + + + org.apache.maven.plugins + maven-compiler-plugin + + 7 + 7 + + + + diff --git a/src/main/java/io/zipcoder/casino/CardFactory.java b/src/main/java/io/zipcoder/casino/CardFactory.java new file mode 100644 index 000000000..be433d146 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CardFactory.java @@ -0,0 +1,8 @@ +package io.zipcoder.casino; + +public class CardFactory { + +// public static Card(String nameOfCard, String suitOfCard, int value) { +// return new Card(nameOfCard, suitOfCard, value); +// } +} diff --git a/src/main/java/io/zipcoder/casino/GamblingPlayer.java b/src/main/java/io/zipcoder/casino/GamblingPlayer.java new file mode 100644 index 000000000..02024a1e7 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/GamblingPlayer.java @@ -0,0 +1,8 @@ +package io.zipcoder.casino; + +public interface GamblingPlayer { + + void wageMoney(int wageAmount); + void cashOut(); + void getMoreChips(int buyAmount); +} diff --git a/src/main/java/io/zipcoder/casino/Player.java b/src/main/java/io/zipcoder/casino/Player.java new file mode 100644 index 000000000..9fa06687b --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Player.java @@ -0,0 +1,67 @@ +package io.zipcoder.casino; + +public class Player implements GamblingPlayer{ + private String playerName; + private final int playerID; + private int wallet; + private int chipBalance; + + public Player(String playerName, int wallet) { + this.playerName = playerName; + this.playerID = (int)(Math.random() * ((9999 - 1000) + 1) + 1000); + this.wallet = wallet; + this.chipBalance = 0; + } + + public String getPlayerName() { + return playerName; + } + + public void setPlayerName(String playerName) { + this.playerName = playerName; + } + + public int getPlayerID() { + return playerID; + } + + public int getWallet() { + return wallet; + } + + public void setWallet(int wallet) { + this.wallet = wallet; + } + + public int getChipBalance() { + return chipBalance; + } + + public void setChipBalance(int chipBalance) { + this.chipBalance = chipBalance; + } + + public void addToWallet(int newMoney) { + if(newMoney >= 0) { + wallet += newMoney; + } + } + + public void wageMoney(int wageAmount) { + if(wageAmount >= 0) { + chipBalance -= wageAmount; + } + } + + public void cashOut() { + wallet += chipBalance; + chipBalance = 0; + } + + public void getMoreChips(int buyAmount) { + if(buyAmount >= 0) { + wallet -= buyAmount; + chipBalance += buyAmount; + } + } +} diff --git a/src/main/java/io/zipcoder/casino/PlayerFactory.java b/src/main/java/io/zipcoder/casino/PlayerFactory.java new file mode 100644 index 000000000..36a663f3c --- /dev/null +++ b/src/main/java/io/zipcoder/casino/PlayerFactory.java @@ -0,0 +1,8 @@ +package io.zipcoder.casino; + +public class PlayerFactory { + + public static Player createPlayer(String name, int wallet) { + return new Player(name, wallet); + } +} diff --git a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java new file mode 100644 index 000000000..f6a224b17 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java @@ -0,0 +1,24 @@ +package io.zipcoder.casino; + +import java.util.HashMap; +import java.util.Map; + +public class PlayerWarehouse { + private static Map currentPlayers = new HashMap<>(); + + public static void addPlayer(int playerID, Player player) { + currentPlayers.put(playerID, player); + } + + public static void removePlayer(int playerID) { + currentPlayers.remove(playerID); + } + + public static Integer getNumberOfCurrentPlayers() { + return currentPlayers.size(); + } + + public static void removeAllPlayers() { + currentPlayers.clear(); + } +} diff --git a/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java b/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java new file mode 100644 index 000000000..8caacf23a --- /dev/null +++ b/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java @@ -0,0 +1,203 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PlayerFactoryTest { + + @Test + public void createPlayerNameTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + String actual = gerg.getPlayerName(); + + //Then + Assert.assertEquals(name, actual); + } + + @Test + public void createPlayerWalletTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int actual = gerg.getWallet(); + + //Then + Assert.assertEquals(walletsize, actual); + } + + @Test + public void createPlayerIDTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int actual = gerg.getPlayerID(); + + //Then: + Assert.assertTrue(actual <= 9999 && actual >= 1000); + } + + @Test + public void setWalletTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int expected = 69420; + gerg.setWallet(expected); + int actual = gerg.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getChipBalanceTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int expected = 0; + int actual = gerg.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void setChipBalanceTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int expected = 2570; + gerg.setChipBalance(expected); + int actual = gerg.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void addToWalletTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int amountToAdd = 1500; + int expected = 1920; + gerg.addToWallet(amountToAdd); + int actual = gerg.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void wageMoneyTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + int betAmount = 500; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + gerg.setChipBalance(2500); + int expected = 2000; + gerg.wageMoney(betAmount); + int actual = gerg.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void cashOutTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + gerg.setChipBalance(2500); + int expected = 2920; + gerg.cashOut(); + int actual = gerg.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getMoreChipsTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + int expected = 420; + gerg.getMoreChips(expected); + int actual = gerg.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getMoreChipsWithBalanceTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + int chipsWanted = 320; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + gerg.setChipBalance(600); + int expected = 920; + gerg.getMoreChips(chipsWanted); + int actual = gerg.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getMoreChipsRemainingWalletTest() { + //Given: + String name = "GergDon"; + int walletsize = 420; + int chipsWanted = 320; + + //When: + Player gerg = PlayerFactory.createPlayer(name, walletsize); + gerg.setChipBalance(600); + int expected = 100; + gerg.getMoreChips(chipsWanted); + int actual = gerg.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/PlayerTest.java b/src/test/java/io/zipcoder/casino/PlayerTest.java new file mode 100644 index 000000000..945591586 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/PlayerTest.java @@ -0,0 +1,196 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PlayerTest { + String name = "Gerg"; + int stash = 5000; + + @Test + public void getPlayerNameTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + String expected = "Gerg"; + String actual = gamblingAddict.getPlayerName(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void setPlayerNameTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + String expected = "Don"; + gamblingAddict.setPlayerName(expected); + String actual = gamblingAddict.getPlayerName(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getPlayerIDTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int actual = gamblingAddict.getPlayerID(); + + //Then: + Assert.assertTrue(actual <= 9999 && actual >= 1000); + } + + @Test + public void getWalletTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int expected = 5000; + int actual = gamblingAddict.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void setWalletTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int expected = 69420; + gamblingAddict.setWallet(expected); + int actual = gamblingAddict.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getChipBalanceTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int expected = 0; + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void setChipBalanceTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int expected = 2570; + gamblingAddict.setChipBalance(expected); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void addToWalletTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int amountToAdd = 1500; + int expected = 6500; + gamblingAddict.addToWallet(amountToAdd); + int actual = gamblingAddict.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void wageMoneyTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(2500); + int betAmount = 500; + + //When: + int expected = 2000; + gamblingAddict.wageMoney(betAmount); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void cashOutTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(2500); + + //When: + int expected = 7500; + gamblingAddict.cashOut(); + int actual = gamblingAddict.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getMoreChipsTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + + //When: + int expected = 4000; + gamblingAddict.getMoreChips(expected); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getMoreChipsWithBalanceTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(5000); + int chipsWanted = 3000; + + //When: + int expected = 8000; + gamblingAddict.getMoreChips(chipsWanted); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void getMoreChipsRemainingWalletTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(5000); + int chipsWanted = 3000; + + //When: + int expected = 2000; + gamblingAddict.getMoreChips(chipsWanted); + int actual = gamblingAddict.getWallet(); + + //Then: + Assert.assertEquals(expected, actual); + } +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java new file mode 100644 index 000000000..874c84f6e --- /dev/null +++ b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java @@ -0,0 +1,71 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PlayerWarehouseTest { + + @Test + public void addPlayer() { + //Given: + Player gerg = PlayerFactory.createPlayer("gerg", 500); + int playerID = gerg.getPlayerID(); + + //When: + PlayerWarehouse.removeAllPlayers(); + PlayerWarehouse.addPlayer(playerID, gerg); + + //Then: + Assert.assertEquals(1, (int) PlayerWarehouse.getNumberOfCurrentPlayers()); + } + + @Test + public void removePlayer() { + //Given: + Player gerg = PlayerFactory.createPlayer("gerg", 500); + Player eab = PlayerFactory.createPlayer("eab", 500); + Player nixog = PlayerFactory.createPlayer("nixog", 500); + int gergPlayerID = gerg.getPlayerID(); + int eabPlayerID = eab.getPlayerID(); + int nixogPlayerID = nixog.getPlayerID(); + PlayerWarehouse.removeAllPlayers(); + PlayerWarehouse.addPlayer(gergPlayerID, gerg); + PlayerWarehouse.addPlayer(eabPlayerID, eab); + PlayerWarehouse.addPlayer(nixogPlayerID, nixog); + + //When: + PlayerWarehouse.removePlayer(gergPlayerID); + + + //Then: + Assert.assertEquals(2, (int) PlayerWarehouse.getNumberOfCurrentPlayers()); + } + + @Test + public void getNumberOfCurrentPlayers() { + //Given: + Player gerg = PlayerFactory.createPlayer("gerg", 500); + Player eab = PlayerFactory.createPlayer("eab", 500); + Player nixog = PlayerFactory.createPlayer("nixog", 500); + int gergPlayerID = gerg.getPlayerID(); + int eabPlayerID = eab.getPlayerID(); + int nixogPlayerID = nixog.getPlayerID(); + PlayerWarehouse.removeAllPlayers(); + PlayerWarehouse.addPlayer(gergPlayerID, gerg); + PlayerWarehouse.addPlayer(eabPlayerID, eab); + PlayerWarehouse.addPlayer(nixogPlayerID, nixog); + + //When: + PlayerWarehouse.removePlayer(gergPlayerID); + + + //Then: + Assert.assertEquals(2, (int) PlayerWarehouse.getNumberOfCurrentPlayers()); + } + + @Test + public void removeAllPlayers() { + } +} \ No newline at end of file From e433428fc358b179d38a5a97a0e4770e3d156c3b Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Mon, 15 Mar 2021 20:19:30 -0400 Subject: [PATCH 12/73] upgraded CardGame Class --- .../java/io/zipcoder/casino/CardGame.java | 49 +++++++++++++++---- 1 file changed, 39 insertions(+), 10 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java index 68331736f..4ff3f8d04 100644 --- a/src/main/java/io/zipcoder/casino/CardGame.java +++ b/src/main/java/io/zipcoder/casino/CardGame.java @@ -1,15 +1,17 @@ package io.zipcoder.casino; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; import java.util.List; abstract class CardGame implements Game { private List deck=new ArrayList(); private ListdiscardPile=new ArrayList(); - private List playerHand=new ArrayList(); - private List dealerHand=new ArrayList(); + + public List playerHand=new ArrayList(); + public List dealerHand=new ArrayList(); + + private Card AceOfSpades=new Card("A", "Spades", 11); private Card TwoOfSpades=new Card("2", "Spades", 2); private Card ThreeOfSpades=new Card("3", "Spades", 3); @@ -68,13 +70,16 @@ abstract class CardGame implements Game { - - + //empties all hands, decks, and discard piles. Used to make new game state. + public void clearTable(){ + deck.clear(); + playerHand.clear(); + dealerHand.clear(); + discardPile.clear(); + } //method to set deck to new deck. - //clears out deck then fills with all 52 cards. public void makeDeck(){ - if (deck!=null){deck.clear();} deck.add(AceOfSpades); deck.add(TwoOfSpades); deck.add(ThreeOfSpades); @@ -148,8 +153,32 @@ public void dealCards(int whichPlayer){ deck.remove(0); }else System.out.println("Pick player one or two, please."); - }; + } - //temporary, I don't actually know what this is for as of yet. - //public void discardPileReshuffle(){}; + public void discardCards(int cardIndex, int whichPlayer){ + if(whichPlayer==1){ + discardPile.add(playerHand.get(cardIndex)); + playerHand.remove(cardIndex); + }else if(whichPlayer==2){ + discardPile.add(dealerHand.get(cardIndex)); + dealerHand.remove(cardIndex); + }else System.out.println("Pick player one or two, please."); + } + + public void discardHand(int whichPlayer){ + if(whichPlayer==1){ + discardPile.addAll(playerHand); + playerHand.clear(); + }else if(whichPlayer==2){ + discardPile.addAll(dealerHand); + dealerHand.clear(); + }else System.out.println("Pick player one or two, please."); + } + + //Lets you reshuffle the discard into the deck. + public void discardPileReshuffle(){ + deck.addAll(discardPile); + discardPile.clear(); + shuffleDeck(); + }; } From f87dc55c245b2a34d43138e082704c21c9afb79e Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Mon, 15 Mar 2021 20:54:59 -0400 Subject: [PATCH 13/73] minor comments added for documentation purposes --- src/main/java/io/zipcoder/casino/CardGame.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java index 4ff3f8d04..2b1dd03d3 100644 --- a/src/main/java/io/zipcoder/casino/CardGame.java +++ b/src/main/java/io/zipcoder/casino/CardGame.java @@ -8,6 +8,7 @@ abstract class CardGame implements Game { private List deck=new ArrayList(); private ListdiscardPile=new ArrayList(); + //public so inherited classes can modify these values. public List playerHand=new ArrayList(); public List dealerHand=new ArrayList(); @@ -138,7 +139,7 @@ public void makeDeck(){ }; - //shuffles a chosen arraylist. + //shuffles the deck. That's it. Needed since the deck is private. public void shuffleDeck(){ Collections.shuffle(deck); }; @@ -155,6 +156,7 @@ public void dealCards(int whichPlayer){ } + //Lets player or dealer discard into discard pile public void discardCards(int cardIndex, int whichPlayer){ if(whichPlayer==1){ discardPile.add(playerHand.get(cardIndex)); @@ -165,6 +167,7 @@ public void discardCards(int cardIndex, int whichPlayer){ }else System.out.println("Pick player one or two, please."); } + //Lets player or dealer discard whole hand into discard pile public void discardHand(int whichPlayer){ if(whichPlayer==1){ discardPile.addAll(playerHand); From 1e5847ff2f010529c7cb296e931b250d6719fb90 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Mon, 15 Mar 2021 22:22:13 -0400 Subject: [PATCH 14/73] cards work now lol --- pom.xml | 6 +++ src/main/java/io/zipcoder/casino/Card.java | 6 +-- .../java/io/zipcoder/casino/GoFishTest.java | 17 +++++++++ .../java/io/zipcoder/casino/CardTest.java | 37 +++++++++++++++++++ 4 files changed, 63 insertions(+), 3 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/GoFishTest.java create mode 100644 src/test/java/io/zipcoder/casino/CardTest.java diff --git a/pom.xml b/pom.xml index a1b0ae8dc..99b6aed53 100644 --- a/pom.xml +++ b/pom.xml @@ -27,5 +27,11 @@ 4.12 test + + org.junit.jupiter + junit-jupiter + RELEASE + compile + diff --git a/src/main/java/io/zipcoder/casino/Card.java b/src/main/java/io/zipcoder/casino/Card.java index 921545626..6622e5031 100644 --- a/src/main/java/io/zipcoder/casino/Card.java +++ b/src/main/java/io/zipcoder/casino/Card.java @@ -14,15 +14,15 @@ public Card(String name, String suit, Integer value){ cardValue=value; } - private String getCardName(){ + public String getCardName(){ return cardName; } - private Integer getValue(){ + public Integer getValue(){ return cardValue; } - private String getCardSuit(){ + public String getCardSuit(){ return cardSuit; } } diff --git a/src/main/java/io/zipcoder/casino/GoFishTest.java b/src/main/java/io/zipcoder/casino/GoFishTest.java new file mode 100644 index 000000000..12708a9fd --- /dev/null +++ b/src/main/java/io/zipcoder/casino/GoFishTest.java @@ -0,0 +1,17 @@ +package io.zipcoder.casino; + + +import org.junit.jupiter.api.Test; + +public class GoFishTest { + + + @Test + public void constructorGameTest(){ + GoFish friendlyGame = new GoFish(); + } + + + + +} diff --git a/src/test/java/io/zipcoder/casino/CardTest.java b/src/test/java/io/zipcoder/casino/CardTest.java new file mode 100644 index 000000000..0b8aa8fb5 --- /dev/null +++ b/src/test/java/io/zipcoder/casino/CardTest.java @@ -0,0 +1,37 @@ +package io.zipcoder.casino; + +import org.junit.Assert; +import org.junit.Test; + +public class CardTest { + + @Test + public void constructorTest(){ + Card joker= new Card("3", "Hearts", 3); + Assert.assertTrue(joker instanceof Card); + } + + @Test + public void getCardNameTest(){ + Card joker= new Card("3", "Hearts", 3); + String expected = "3"; + String actual = joker.getCardName(); + Assert.assertEquals(expected,actual); + } + + @Test + public void getCardSuitTest(){ + Card joker= new Card("3", "Hearts", 3); + String expected = "Hearts"; + String actual = joker.getCardSuit(); + Assert.assertEquals(expected,actual); + } + + @Test + public void getCardValueTest(){ + Card joker= new Card("3", "Hearts", 3); + Integer expected = 3; + Integer actual = joker.getValue(); + Assert.assertEquals(expected,actual); + } +} From dc7f247c56cd182af51bce087be24d28dea0edba Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Mon, 15 Mar 2021 22:26:03 -0400 Subject: [PATCH 15/73] Boolean --- src/main/java/io/zipcoder/casino/Game.java | 2 +- src/main/java/io/zipcoder/casino/GoFishTest.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Game.java b/src/main/java/io/zipcoder/casino/Game.java index f40926cc6..e69fec54c 100644 --- a/src/main/java/io/zipcoder/casino/Game.java +++ b/src/main/java/io/zipcoder/casino/Game.java @@ -4,5 +4,5 @@ public interface Game { public void playGame(); - public boolean checkWinner(); + public Boolean checkWinner(); } diff --git a/src/main/java/io/zipcoder/casino/GoFishTest.java b/src/main/java/io/zipcoder/casino/GoFishTest.java index 12708a9fd..66da15f2a 100644 --- a/src/main/java/io/zipcoder/casino/GoFishTest.java +++ b/src/main/java/io/zipcoder/casino/GoFishTest.java @@ -8,7 +8,7 @@ public class GoFishTest { @Test public void constructorGameTest(){ - GoFish friendlyGame = new GoFish(); + // GoFish friendlyGame = new GoFish(); } From 60cfa6e6583322cbb75a17b4183b57da0ce6bf17 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Mon, 15 Mar 2021 22:32:46 -0400 Subject: [PATCH 16/73] updated a bunch of stuff --- .../java/io/zipcoder/casino/BlackJack.java | 72 ++++++++++ .../io/zipcoder/casino/GamblingPlayer.java | 2 + src/main/java/io/zipcoder/casino/Player.java | 8 ++ .../io/zipcoder/casino/BlackJackTest.java | 130 ++++++++++++++++++ .../java/io/zipcoder/casino/PlayerTest.java | 32 +++++ .../zipcoder/casino/PlayerWarehouseTest.java | 18 ++- 6 files changed, 260 insertions(+), 2 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/BlackJack.java create mode 100644 src/test/java/io/zipcoder/casino/BlackJackTest.java diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java new file mode 100644 index 000000000..c8b0abc37 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -0,0 +1,72 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; +import java.util.List; + +public class BlackJack extends CardGame { + Player currentPlayer; + public List playerSplitHand = new ArrayList<>(); + public List dealerSplitHand = new ArrayList<>(); + public int playerTotal; + public int dealerTotal; + public int sizeOfPot; + + public BlackJack(Player currentPlayer) { + this.currentPlayer = currentPlayer; + } + + public void addToPot(int chipsAdded) { + currentPlayer.bet(chipsAdded); + sizeOfPot += chipsAdded; + } + + public void playerWinPot() { + currentPlayer.winChips(sizeOfPot*2); + sizeOfPot = 0; + } + + public void playerBlackJack() { + currentPlayer.winChips(sizeOfPot*3); + sizeOfPot = 0; + } + + @Override + public void playGame() { + makeDeck(); + shuffleDeck(); + for(int i = 0; i < 2; i++) { + dealCards(1); + playerTotal = playerHand.get(i).getValue(); + dealCards(2); + dealerTotal = dealerHand.get(i).getValue(); + } + } + + @Override + public boolean checkWinner() { + if(playerTotal == 21 && dealerTotal != 21) return true; + else if(playerTotal > dealerTotal && playerTotal <= 21) return true; + else if(dealerTotal > 21) return true; + else if(dealerTotal == 21) return false; + else if (dealerTotal > playerTotal) return false; + else return false; + } + + public void playerHandSplit() { + playerSplitHand.add(playerHand.remove(0)); + } + + public void dealerHandSplit() { + dealerSplitHand.add(dealerHand.remove(0)); + } + + public boolean playerBust() { + if (playerTotal > 21) return true; + else return false; + } + + public boolean dealerBust() { + if (dealerTotal > 21) return true; + else return false; + } +} diff --git a/src/main/java/io/zipcoder/casino/GamblingPlayer.java b/src/main/java/io/zipcoder/casino/GamblingPlayer.java index 02024a1e7..958d20b70 100644 --- a/src/main/java/io/zipcoder/casino/GamblingPlayer.java +++ b/src/main/java/io/zipcoder/casino/GamblingPlayer.java @@ -5,4 +5,6 @@ public interface GamblingPlayer { void wageMoney(int wageAmount); void cashOut(); void getMoreChips(int buyAmount); + void winChips(int chipsWon); + void bet(int amount); } diff --git a/src/main/java/io/zipcoder/casino/Player.java b/src/main/java/io/zipcoder/casino/Player.java index 9fa06687b..448601af1 100644 --- a/src/main/java/io/zipcoder/casino/Player.java +++ b/src/main/java/io/zipcoder/casino/Player.java @@ -64,4 +64,12 @@ public void getMoreChips(int buyAmount) { chipBalance += buyAmount; } } + + public void winChips(int chipsWon) { + chipBalance += chipsWon; + } + + public void bet(int amount) { + chipBalance -= amount; + } } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java new file mode 100644 index 000000000..73c9cc5be --- /dev/null +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -0,0 +1,130 @@ +package io.zipcoder.casino; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class BlackJackTest { + Player gerg = PlayerFactory.createPlayer("gerg", 5000); + BlackJack bj = new BlackJack(gerg); + + + @Test + public void addToPotTest() { + //Given: + gerg.setChipBalance(3000); + + //When: + int expected = 500; + bj.addToPot(expected); + int actual = bj.sizeOfPot; + + //Then: + assertEquals(expected, actual); + } + + @Test + public void addToPotPlayerBalanceTest() { + //Given: + gerg.setChipBalance(3000); + + //When: + bj.addToPot(500); + int expected = 2500; + int actual = gerg.getChipBalance(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerWinPotTest() { + //Given: + gerg.setChipBalance(3000); + + //When: + bj.addToPot(500); + bj.playerWinPot(); + int expected = 3500; + int actual = gerg.getChipBalance(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerWinPotBalanceTest() { + //Given: + gerg.setChipBalance(3000); + + //When: + bj.addToPot(500); + bj.playerWinPot(); + int expected = 0; + int actual = bj.sizeOfPot; + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerBlackJackTest() { + //Given: + gerg.setChipBalance(3000); + + //When: + bj.addToPot(500); + bj.playerBlackJack(); + int expected = 4000; + int actual = gerg.getChipBalance(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playGamePlayerHandTest() { + //Given: + bj.playGame(); + + //When: + int expected = 2; + int actual = bj.playerHand.size(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playGameDealerHandTest() { + //Given: + bj.playGame(); + + //When: + int expected = 2; + int actual = bj.dealerHand.size(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void checkWinner() { + } + + @Test + public void playerHandSplit() { + } + + @Test + public void dealerHandSplit() { + } + + @Test + public void playerBust() { + } + + @Test + public void dealerBust() { + } +} \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/PlayerTest.java b/src/test/java/io/zipcoder/casino/PlayerTest.java index 945591586..a3690a18b 100644 --- a/src/test/java/io/zipcoder/casino/PlayerTest.java +++ b/src/test/java/io/zipcoder/casino/PlayerTest.java @@ -193,4 +193,36 @@ public void getMoreChipsRemainingWalletTest() { //Then: Assert.assertEquals(expected, actual); } + + @Test + public void winChipsTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(5000); + int chipsWon = 167; + + //When: + int expected = 5167; + gamblingAddict.winChips(chipsWon); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + + @Test + public void betTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(5000); + int betAmount = 250; + + //When: + int expected = 4750; + gamblingAddict.bet(betAmount); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } } \ No newline at end of file diff --git a/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java index 874c84f6e..68d67797b 100644 --- a/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java +++ b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java @@ -38,7 +38,6 @@ public void removePlayer() { //When: PlayerWarehouse.removePlayer(gergPlayerID); - //Then: Assert.assertEquals(2, (int) PlayerWarehouse.getNumberOfCurrentPlayers()); } @@ -60,12 +59,27 @@ public void getNumberOfCurrentPlayers() { //When: PlayerWarehouse.removePlayer(gergPlayerID); - //Then: Assert.assertEquals(2, (int) PlayerWarehouse.getNumberOfCurrentPlayers()); } @Test public void removeAllPlayers() { + //Given: + Player gerg = PlayerFactory.createPlayer("gerg", 500); + Player eab = PlayerFactory.createPlayer("eab", 500); + Player nixog = PlayerFactory.createPlayer("nixog", 500); + int gergPlayerID = gerg.getPlayerID(); + int eabPlayerID = eab.getPlayerID(); + int nixogPlayerID = nixog.getPlayerID(); + PlayerWarehouse.addPlayer(gergPlayerID, gerg); + PlayerWarehouse.addPlayer(eabPlayerID, eab); + PlayerWarehouse.addPlayer(nixogPlayerID, nixog); + + //When: + PlayerWarehouse.removeAllPlayers(); + + //Then: + Assert.assertEquals(0, (int) PlayerWarehouse.getNumberOfCurrentPlayers()); } } \ No newline at end of file From 9246c79ad607547688937f90a60719e9ebe8a894 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 23:08:56 -0400 Subject: [PATCH 17/73] craps should be fully written, passing all tests --- src/main/java/io/zipcoder/casino/Craps.java | 106 ++++++- .../java/io/zipcoder/casino/CrapsTest.java | 265 +++++++++++++++++- 2 files changed, 354 insertions(+), 17 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java index 943d048e9..e223955c9 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -1,8 +1,12 @@ package io.zipcoder.casino; public class Craps extends DiceGame { - int gameRound; - String passOrNot = ""; + int gameRound = 1; + String betStatus; + Integer[] roundOnePass = new Integer[]{7, 11}; + Integer[] roundOneNotPass = new Integer[]{2, 3, 12}; + Integer[] rollAgain = new Integer[]{4, 5, 6, 8, 9, 10}; + int pointer; public void addToPot(int numOfChips) { pot += numOfChips; @@ -11,4 +15,102 @@ public void addToPot(int numOfChips) { public int getPot() { return pot; } + + + //1: player wins, 2: dealer wins, 3: move to next round + public int checkWinnerRoundOne(int sumOfDice) { + int outcome = 0; + if (getBetStatus().equalsIgnoreCase("Pass")) { + for (int i : roundOnePass) { + if (sumOfDice == i) { + outcome = 1; + } + } + for (int i : roundOneNotPass) { + if (sumOfDice == i) { + outcome = 2; + } + } + for (int i : rollAgain) { + if (sumOfDice == i) { + outcome = 3; + } + } + } else if (getBetStatus().equalsIgnoreCase("Not Pass")) { + for (int i : roundOnePass) { + if (sumOfDice == i) { + outcome = 2; + } + } + for (int i : roundOneNotPass) { + if (sumOfDice == i) { + outcome = 1; + } + } + for (int i : rollAgain) { + if (sumOfDice == i) { + outcome = 3; + } + } + } + return outcome; + } + + + + //1: player wins, 2: player loses, 3: roll again + public int checkWinnerRoundTwo(int sumOfDice) { + int outcome; + if (getBetStatus().equalsIgnoreCase("Pass")) { + if (sumOfDice == getPointer()) { + outcome = 1; + } else if (sumOfDice == 7) { + outcome = 2; + } else { + outcome = 3; + } + } else { + //catches "NotPass" status + if (sumOfDice == 7) { + outcome = 1; + } else if (sumOfDice == getPointer()) { + outcome = 2; + } else { + outcome = 3; + } + } + return outcome; + } + + public int sumOfDice() { + int sum = 0; + for (int i = 0; i < 2; i++) { + sum += rollDice(); + } + return sum; + } + + public void setGameRound(int round) { + gameRound = round; + } + + public int getGameRound() { + return gameRound; + } + + public void setPointer(int pointer) { + this.pointer = pointer; + } + + public int getPointer() { + return this.pointer; + } + + public void setBetStatus(String betStatus) { + this.betStatus = betStatus; + } + + public String getBetStatus() { + return this.betStatus; + } } diff --git a/src/test/java/io/zipcoder/casino/CrapsTest.java b/src/test/java/io/zipcoder/casino/CrapsTest.java index 27e664dd7..ee21e2624 100644 --- a/src/test/java/io/zipcoder/casino/CrapsTest.java +++ b/src/test/java/io/zipcoder/casino/CrapsTest.java @@ -5,14 +5,15 @@ public class CrapsTest { + //SuperClass tests @Test public void getPot() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); + Craps craps = new Craps(); int expected = 0; //When - int actual = yahtzee.getPot(); + int actual = craps.getPot(); //Then Assert.assertEquals(expected, actual); @@ -21,12 +22,12 @@ public void getPot() { @Test public void addToPot() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); + Craps craps = new Craps(); int expected = 5; //When - yahtzee.addToPot(5); - int actual = yahtzee.getPot(); + craps.addToPot(5); + int actual = craps.getPot(); //Then Assert.assertEquals(expected, actual); @@ -35,13 +36,13 @@ public void addToPot() { @Test public void clearPot() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); + Craps craps = new Craps(); int expected = 0; - yahtzee.addToPot(7); - yahtzee.clearPot(); + craps.addToPot(7); + craps.clearPot(); //When - int actual = yahtzee.getPot(); + int actual = craps.getPot(); //Then Assert.assertEquals(expected, actual); @@ -50,25 +51,259 @@ public void clearPot() { @Test public void rollDice() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); + Craps craps = new Craps(); //When - int result = yahtzee.rollDice(); + int result = craps.rollDice(); //Then Assert.assertTrue(result > 0 && result < 7); } + + //Unique to Craps + @Test + public void setGameRound() { + //Given + Craps craps = new Craps(); + int expected = 1; + + //When + craps.setGameRound(1); + int actual = craps.getGameRound(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void setGetPointer() { + //Given + Craps craps = new Craps(); + int expected = 8; + + //When + craps.setPointer(8); + int actual = craps.getPointer(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void setGetBetStatus() { + //Given + Craps craps = new Craps(); + String expected = "Pass"; + + //When + craps.setBetStatus("Pass"); + String actual = craps.getBetStatus(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void sumOfDice() { + //Given + Craps craps = new Craps(); + + //When + int actual = craps.sumOfDice(); + + //Then + Assert.assertTrue(actual > 1 && actual < 13); + } + + //Round One Pass Outcomes + @Test + public void playerWinsRoundOnePass() { + //Given + Craps craps = new Craps(); + int expected = 1; + craps.setBetStatus("Pass"); + + //When + int dieSum = 7; + int actual = craps.checkWinnerRoundOne(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void playerLosesRoundOnePass() { + //Given + Craps craps = new Craps(); + int expected = 2; + craps.setBetStatus("Pass"); + + //When + int dieSum = 2; + int actual = craps.checkWinnerRoundOne(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void playerRollsAgainPass() { + //Given + Craps craps = new Craps(); + int expected = 3; + craps.setBetStatus("Pass"); + + //When + int dieSum = 4; + int actual = craps.checkWinnerRoundOne(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + //Round One Not Pass Outcomes + @Test + public void playerWinsRoundOneNotPass() { + //Given + Craps craps = new Craps(); + int expected = 1; + craps.setBetStatus("Not Pass"); + + //When + int dieSum = 2; + int actual = craps.checkWinnerRoundOne(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void playerLosesRoundOneNotPass() { + //Given + Craps craps = new Craps(); + int expected = 2; + craps.setBetStatus("Not Pass"); + + //When + int dieSum = 7; + int actual = craps.checkWinnerRoundOne(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void playerRollsAgainRoundOneNotPass() { + //Given + Craps craps = new Craps(); + int expected = 3; + craps.setBetStatus("Not Pass"); + + //When + int dieSum = 9; + int actual = craps.checkWinnerRoundOne(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + //Round Two Pass Outcomes + @Test + public void playerWinsRoundTwoPass() { + //Given + Craps craps = new Craps(); + int expected = 1; + craps.setBetStatus("Pass"); + craps.setPointer(10); + + //When + int dieSum = 10; + int actual = craps.checkWinnerRoundTwo(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void playerLosesRoundTwoPass() { + //Given + Craps craps = new Craps(); + int expected = 2; + craps.setBetStatus("Pass"); + craps.setPointer(10); + + //When + int dieSum = 7; + int actual = craps.checkWinnerRoundTwo(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void playerRollsAgainRoundTwoPass() { + //Given + Craps craps = new Craps(); + int expected = 3; + craps.setBetStatus("Pass"); + craps.setPointer(10); + + //When + int dieSum = 4; + int actual = craps.checkWinnerRoundTwo(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + + //Round Two Not Pass Outcomes + @Test + public void playerWinsRoundTwoNotPass() { + //Given + Craps craps = new Craps(); + int expected = 1; + craps.setBetStatus("Not Pass"); + craps.setPointer(10); + + //When + int dieSum = 7; + int actual = craps.checkWinnerRoundTwo(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + @Test - public void checkWinner() { + public void playerLosesRoundTwoNotPass() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); - boolean expected = false; + Craps craps = new Craps(); + int expected = 2; + craps.setBetStatus("Not Pass"); + craps.setPointer(10); //When - boolean actual = yahtzee.checkWinner(); + int dieSum = 10; + int actual = craps.checkWinnerRoundTwo(dieSum); //Then Assert.assertEquals(expected, actual); } + + @Test + public void playerRollsAgainRoundTwoNotPass() { + //Given + Craps craps = new Craps(); + int expected = 3; + craps.setBetStatus("Not Pass"); + craps.setPointer(10); + + //When + int dieSum = 11; + int actual = craps.checkWinnerRoundTwo(dieSum); + + //Then + Assert.assertEquals(expected, actual); + } + } From f4a6f940b7f1f03d68c5b563dfa0c33da16ba108 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Mon, 15 Mar 2021 23:31:31 -0400 Subject: [PATCH 18/73] updated MostOfAKind and tests. Includes more getters and methods to make the hands for player and dealer. HandMakers are flexible to include the second roll being a different number of dice --- .../java/io/zipcoder/casino/DiceGame.java | 2 +- .../io/zipcoder/casino/MostOfAKindGame.java | 30 ++++++++++++++++++- .../io/zipcoder/casino/MostOfAKindTests.java | 26 ++++++++++++++++ 3 files changed, 56 insertions(+), 2 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/DiceGame.java b/src/main/java/io/zipcoder/casino/DiceGame.java index 2de626c77..5e34aca46 100644 --- a/src/main/java/io/zipcoder/casino/DiceGame.java +++ b/src/main/java/io/zipcoder/casino/DiceGame.java @@ -4,7 +4,7 @@ public abstract class DiceGame implements GamblingGame { private int totalNumOfDice; - ArrayList playerDiceHand; + ArrayList playerDiceHand = new ArrayList(); int pot = 0; public void addToPot() {} diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 901701101..7c75fcc1c 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -3,9 +3,12 @@ import io.zipcoder.casino.DiceGame; import java.util.ArrayList; +import java.util.Collection; public class MostOfAKindGame extends DiceGame { - ArrayList dealerHand; + ArrayList dealerHand = new ArrayList(); + int playerNumToMatch; + int dealerNumToMatch; int dealerCount; int playerCount; @@ -42,4 +45,29 @@ public void addToPlayerCount(int numOfSameNum) { public void addToDealerCount(int numOfSameNum) { dealerCount += numOfSameNum; } + + public void makeDealerHand(int numOfDice) { + int i = 0; + while (i < numOfDice) { + dealerHand.add(rollDice()); + i++; + } + } + + public void makePlayerHand(int numOfDice) { + int i = 0; + while (i < numOfDice) { + playerDiceHand.add(rollDice()); + i++; + } + } + + public Collection getDealerHand() { + return this.dealerHand; + } + + public Collection getPlayerHand() { + return this.playerDiceHand; + } + } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 8324f286d..12db761da 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -101,4 +101,30 @@ public void checkWinnerPlayer() { Assert.assertTrue(actual); } + @Test + public void makeDealerHand() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + + //When + yahtzee.makeDealerHand(5); + int actual = yahtzee.getDealerHand().size(); + + //Then + Assert.assertEquals(5, actual); + } + + @Test + public void makePlayerHand() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + + //When + yahtzee.makePlayerHand(5); + int actual = yahtzee.getPlayerHand().size(); + + //Then + Assert.assertEquals(5, actual); + } + } From 8e5b3ef9b0fefe9da60d50ef310176745cc251ab Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Tue, 16 Mar 2021 00:02:27 -0400 Subject: [PATCH 19/73] updated blackjack --- .../java/io/zipcoder/casino/BlackJack.java | 36 +++-- .../io/zipcoder/casino/BlackJackTest.java | 124 +++++++++++++++++- 2 files changed, 141 insertions(+), 19 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index c8b0abc37..5df1d206d 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -7,8 +7,11 @@ public class BlackJack extends CardGame { Player currentPlayer; public List playerSplitHand = new ArrayList<>(); public List dealerSplitHand = new ArrayList<>(); + public int currentTurn = 1; public int playerTotal; + public int playerSplitTotal; public int dealerTotal; + public int dealerSplitTotal; public int sizeOfPot; public BlackJack(Player currentPlayer) { @@ -30,43 +33,48 @@ public void playerBlackJack() { sizeOfPot = 0; } + public void hitMe() { + dealCards(currentTurn); + playerTotal += playerHand.get(playerHand.size()-1).getValue(); + } + + public void hold() { + currentTurn = 2; + } + @Override public void playGame() { makeDeck(); shuffleDeck(); for(int i = 0; i < 2; i++) { dealCards(1); - playerTotal = playerHand.get(i).getValue(); + playerTotal += playerHand.get(i).getValue(); dealCards(2); - dealerTotal = dealerHand.get(i).getValue(); + dealerTotal += dealerHand.get(i).getValue(); } } @Override - public boolean checkWinner() { + public Boolean checkWinner() { if(playerTotal == 21 && dealerTotal != 21) return true; else if(playerTotal > dealerTotal && playerTotal <= 21) return true; else if(dealerTotal > 21) return true; - else if(dealerTotal == 21) return false; + else if(playerTotal > 21) return false; + else if(dealerTotal == 21 && playerTotal != 21) return false; else if (dealerTotal > playerTotal) return false; - else return false; + else return null; } public void playerHandSplit() { + playerTotal -= playerHand.get(0).getValue(); playerSplitHand.add(playerHand.remove(0)); + playerSplitTotal += playerSplitHand.get(0).getValue(); } public void dealerHandSplit() { + dealerTotal -= dealerHand.get(0).getValue(); dealerSplitHand.add(dealerHand.remove(0)); + dealerSplitTotal += dealerSplitHand.get(0).getValue(); } - public boolean playerBust() { - if (playerTotal > 21) return true; - else return false; - } - - public boolean dealerBust() { - if (dealerTotal > 21) return true; - else return false; - } } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 73c9cc5be..340cbe96d 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -109,22 +109,136 @@ public void playGameDealerHandTest() { } @Test - public void checkWinner() { + public void playGamePlayerHandValueTest() { + //Given: + bj.playGame(); + + //When: + int actual = bj.playerTotal; + + //Then: + assertTrue(actual > 0); } @Test - public void playerHandSplit() { + public void playGameDealerHandValueTest() { + //Given: + bj.playGame(); + + //When: + int actual = bj.dealerTotal; + + //Then: + assertTrue(actual > 0); } @Test - public void dealerHandSplit() { + public void checkWinnerPlayerWinTest() { + //Given: + bj.playerTotal = 18; + bj.dealerTotal = 17; + + //When: + boolean expected = true; + boolean actual = bj.checkWinner(); + + //Then: + assertEquals(expected, actual); } @Test - public void playerBust() { + public void checkWinnerPlayerBustTest() { + //Given: + bj.playerTotal = 25; + bj.dealerTotal = 17; + + //When: + boolean expected = false; + boolean actual = bj.checkWinner(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void checkWinnerDealerWinsTest() { + //Given: + bj.playerTotal = 19; + bj.dealerTotal = 20; + + //When: + boolean expected = false; + boolean actual = bj.checkWinner(); + + //Then: + assertEquals(expected, actual); } @Test - public void dealerBust() { + public void checkWinnerDealerBustTest() { + //Given: + bj.playerTotal = 16; + bj.dealerTotal = 23; + + //When: + boolean expected = true; + boolean actual = bj.checkWinner(); + + //Then: + assertEquals(expected, actual); } + + @Test + public void checkWinnerPlayerBlackJackTest() { + //Given: + bj.playerTotal = 21; + bj.dealerTotal = 21; + + //When: + Boolean expected = null; + Boolean actual = bj.checkWinner(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void hitMePlayerTest() { + //Given: + bj.playGame(); + + //When: + bj.hitMe(); + bj.hitMe(); + int expected = 4; + int actual = bj.playerHand.size(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void hitMeDealerTest() { + //Given: + bj.playGame(); + + //When: + bj.hitMe(); + bj.hold(); + bj.hitMe(); + int expected = 3; + int actual = bj.dealerHand.size(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerHandSplit() { + } + + @Test + public void dealerHandSplit() { + } + } \ No newline at end of file From 1b5383c6afeaa1d918f7a76f044898b45a0821ff Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 10:58:24 -0400 Subject: [PATCH 20/73] MostOfAKind should be done and tests are written --- .../io/zipcoder/casino/MostOfAKindGame.java | 72 ++++++++- .../io/zipcoder/casino/MostOfAKindTests.java | 144 ++++++++++++++++++ 2 files changed, 212 insertions(+), 4 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 7c75fcc1c..846b72182 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -2,13 +2,14 @@ import io.zipcoder.casino.DiceGame; +import java.lang.reflect.Array; import java.util.ArrayList; import java.util.Collection; public class MostOfAKindGame extends DiceGame { ArrayList dealerHand = new ArrayList(); - int playerNumToMatch; - int dealerNumToMatch; + int playerMatchingNum; + int dealerMatchingNum; int dealerCount; int playerCount; @@ -37,6 +38,7 @@ public boolean checkWinner() { } return doIWin; } + public void addToPlayerCount(int numOfSameNum) { playerCount += numOfSameNum; @@ -62,12 +64,74 @@ public void makePlayerHand(int numOfDice) { } } - public Collection getDealerHand() { + public ArrayList getDealerHand() { return this.dealerHand; } - public Collection getPlayerHand() { + public ArrayList getPlayerHand() { return this.playerDiceHand; } + public void exchangePlayerDice(int numToKeep) { + ArrayList newHand = new ArrayList(); + int numOfDiceKeeping = 0; + for (int i = 0; i < getPlayerHand().size(); i++) { + if (getPlayerHand().get(i) == numToKeep) { + newHand.add(getPlayerHand().get(i)); + numOfDiceKeeping++; + } + } + int numOfDiceRollAgain = 5 - numOfDiceKeeping; + playerDiceHand = newHand; + makePlayerHand(numOfDiceRollAgain); + } + + public void exchangeDealerDice(int numToKeep) { + ArrayList newDealerHand = new ArrayList(); + int numOfDiceKeeping = 0; + for (int i = 0; i < getDealerHand().size(); i++) { + if (getDealerHand().get(i) == numToKeep) { + newDealerHand.add(getDealerHand().get(i)); + numOfDiceKeeping++; + } + } + int numOfDiceRollAgain = 5 - numOfDiceKeeping; + dealerHand = newDealerHand; + makeDealerHand(numOfDiceRollAgain); + } + + + public void setPlayerMatchingNum(int matchingNum) { + this.playerMatchingNum = matchingNum; + } + + public int getPlayerMatchingNum() { + return playerMatchingNum; + } + + public void setDealerMatchingNum(int matchingNum) { + this.dealerMatchingNum = matchingNum; + } + + public int getDealerMatchingNum() { + return dealerMatchingNum; + } + + public void playerNumOfMatches(ArrayList playerSecondHand) { + playerCount = 1; + for (int i = 1; i < playerSecondHand.size(); i++) { + if (playerSecondHand.get(i) == playerSecondHand.get(0)) { + playerCount++; + } + } + } + + public void dealerNumOfMatches(ArrayList dealerSecondHand) { + dealerCount = 1; + for (int i = 1; i < dealerSecondHand.size(); i++) { + if (dealerSecondHand.get(i) == dealerSecondHand.get(0)) { + dealerCount++; + } + } + } } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 12db761da..89b661f1a 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -3,6 +3,9 @@ import org.junit.Assert; import org.junit.Test; +import java.lang.reflect.Array; +import java.util.ArrayList; + public class MostOfAKindTests { @Test @@ -126,5 +129,146 @@ public void makePlayerHand() { //Then Assert.assertEquals(5, actual); } + + @Test + public void playerSecondRoll() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(4); + yahtzee.playerDiceHand.add(3); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(6); + ArrayList old = yahtzee.getPlayerHand(); + + //When + yahtzee.exchangePlayerDice(5); + ArrayList newHand = yahtzee.getPlayerHand(); + + //Then + Assert.assertNotEquals(old, newHand); + } + + @Test + public void dealerSecondRoll() { + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(1); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(5); + ArrayList oldHand = yahtzee.getDealerHand(); + + //When + yahtzee.exchangeDealerDice(2); + ArrayList newHand = yahtzee.getDealerHand(); + + //Then + Assert.assertNotEquals(oldHand, newHand); + } + + @Test + public void playerSecondRollIrrational() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(4); + yahtzee.playerDiceHand.add(3); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(6); + ArrayList old = yahtzee.getPlayerHand(); + + //When + yahtzee.exchangePlayerDice(3); + ArrayList newHand = yahtzee.getPlayerHand(); + + //Then + Assert.assertNotEquals(old, newHand); + } + + @Test + public void dealerSecondRollIrrational() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(1); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(5); + ArrayList oldHand = yahtzee.getDealerHand(); + + //When + yahtzee.exchangeDealerDice(5); + ArrayList newHand = yahtzee.getDealerHand(); + + //Then + Assert.assertNotEquals(oldHand, newHand); + } + + @Test + public void setGetPlayerMatchingNum() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.setPlayerMatchingNum(5); + int expected = 5; + + //When + int actual = yahtzee.getPlayerMatchingNum(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void setGetDealerMatchingNum() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.setDealerMatchingNum(2); + int expected = 2; + + //When + int actual = yahtzee.getDealerMatchingNum(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void getPlayerNumOfMatches() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(5); + yahtzee.playerDiceHand.add(3); + yahtzee.playerDiceHand.add(6); + int expected = 3; + + //When + yahtzee.playerNumOfMatches(yahtzee.playerDiceHand); + int actual = yahtzee.getPlayerCount(); + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void getDealerNumOfMatches() { + //Given + MostOfAKindGame yahtzee = new MostOfAKindGame(); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(2); + yahtzee.dealerHand.add(5); + int expected = 4; + + //When + yahtzee.dealerNumOfMatches(yahtzee.dealerHand); + int actual = yahtzee.getDealerCount(); + + //Then + Assert.assertEquals(expected, actual); + } } From 15a7e726e551039b1a628807c5571b21f2fe7400 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Tue, 16 Mar 2021 12:29:07 -0400 Subject: [PATCH 21/73] updated the CardGame class --- pom.xml | 6 +++ .../java/io/zipcoder/casino/CardGame.java | 51 ++++++------------- src/main/java/io/zipcoder/casino/GoFish.java | 27 ++++++++++ .../java/io/zipcoder/casino/GoFishTest.java | 44 +++++++++++++++- 4 files changed, 92 insertions(+), 36 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/GoFish.java diff --git a/pom.xml b/pom.xml index 99b6aed53..80b0d1115 100644 --- a/pom.xml +++ b/pom.xml @@ -33,5 +33,11 @@ RELEASE compile + + junit + junit + 4.13.2 + compile + diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java index 2b1dd03d3..67c1b7c32 100644 --- a/src/main/java/io/zipcoder/casino/CardGame.java +++ b/src/main/java/io/zipcoder/casino/CardGame.java @@ -8,10 +8,6 @@ abstract class CardGame implements Game { private List deck=new ArrayList(); private ListdiscardPile=new ArrayList(); - //public so inherited classes can modify these values. - public List playerHand=new ArrayList(); - public List dealerHand=new ArrayList(); - private Card AceOfSpades=new Card("A", "Spades", 11); private Card TwoOfSpades=new Card("2", "Spades", 2); @@ -71,13 +67,7 @@ abstract class CardGame implements Game { - //empties all hands, decks, and discard piles. Used to make new game state. - public void clearTable(){ - deck.clear(); - playerHand.clear(); - dealerHand.clear(); - discardPile.clear(); - } + //method to set deck to new deck. public void makeDeck(){ @@ -145,37 +135,21 @@ public void shuffleDeck(){ }; //I want this method to pick a random card from the deck and deal it to another arrayList. - public void dealCards(int whichPlayer){ - if(whichPlayer==1){ - playerHand.add(deck.get(0)); - deck.remove(0); - }else if(whichPlayer==2){ - dealerHand.add(deck.get(0)); + public void dealCards(List player){ + player.add(deck.get(0)); deck.remove(0); - }else System.out.println("Pick player one or two, please."); - } //Lets player or dealer discard into discard pile - public void discardCards(int cardIndex, int whichPlayer){ - if(whichPlayer==1){ - discardPile.add(playerHand.get(cardIndex)); - playerHand.remove(cardIndex); - }else if(whichPlayer==2){ - discardPile.add(dealerHand.get(cardIndex)); - dealerHand.remove(cardIndex); - }else System.out.println("Pick player one or two, please."); + public void discardCards(int cardIndex, List player){ + discardPile.add(player.get(cardIndex)); + player.remove(cardIndex); } //Lets player or dealer discard whole hand into discard pile - public void discardHand(int whichPlayer){ - if(whichPlayer==1){ - discardPile.addAll(playerHand); - playerHand.clear(); - }else if(whichPlayer==2){ - discardPile.addAll(dealerHand); - dealerHand.clear(); - }else System.out.println("Pick player one or two, please."); + public void discardHand(List player){ + discardPile.addAll(player); + player.clear(); } //Lets you reshuffle the discard into the deck. @@ -184,4 +158,11 @@ public void discardPileReshuffle(){ discardPile.clear(); shuffleDeck(); }; + + //Empties deck and discard pile. Helps to make new games + public void clearDiscardAndDeck(){ + deck.clear(); + discardPile.clear(); + } + } diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java new file mode 100644 index 000000000..58b606d18 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -0,0 +1,27 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; +import java.util.List; + +public class GoFish extends CardGame { + private List oswald= new ArrayList<>(); + private List dealer= new ArrayList<>(); + + public void playGame() { + } + + public Boolean checkWinner() { + return null; + } + + public Integer cardsInHand(List player){ + return player.size(); + } + + + public String showCard(List player, int indexOfCard) { + String name=player.get(indexOfCard).getCardName(); + String suit=player.get(indexOfCard).getCardSuit(); + return name+" of "+suit; + } +} diff --git a/src/main/java/io/zipcoder/casino/GoFishTest.java b/src/main/java/io/zipcoder/casino/GoFishTest.java index 66da15f2a..25a101e86 100644 --- a/src/main/java/io/zipcoder/casino/GoFishTest.java +++ b/src/main/java/io/zipcoder/casino/GoFishTest.java @@ -1,17 +1,59 @@ package io.zipcoder.casino; +import org.junit.Assert; import org.junit.jupiter.api.Test; +import java.util.ArrayList; + public class GoFishTest { @Test public void constructorGameTest(){ - // GoFish friendlyGame = new GoFish(); + GoFish friendlyGame = new GoFish(); + Assert.assertTrue(friendlyGame instanceof GoFish); + } + + @Test + public void playerHandTest(){ + GoFish friendlyGame=new GoFish(); + friendlyGame.makeDeck(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + Integer actual=friendlyGame.cardsInHand(oswald); + Integer expected = 4; + Assert.assertEquals(actual,expected); } + + + + + @Test + public void testShowCard(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //String actual=friendlyGame.showCard(); + //String expected="4 of Spades"; + //Assert.assertEquals(actual,expected); + } + + + + + + } From c45f963822a5c21ae3b614e30b06fa237b685dd3 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 14:14:13 -0400 Subject: [PATCH 22/73] starting screens. ascii art class if I can figure it out, if not, I'll scrap it --- .../java/io/zipcoder/casino/AsciiArt.java | 9 +++ .../java/io/zipcoder/casino/Displays.java | 74 +++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 src/main/java/io/zipcoder/casino/AsciiArt.java create mode 100644 src/main/java/io/zipcoder/casino/Displays.java diff --git a/src/main/java/io/zipcoder/casino/AsciiArt.java b/src/main/java/io/zipcoder/casino/AsciiArt.java new file mode 100644 index 000000000..32a7827fe --- /dev/null +++ b/src/main/java/io/zipcoder/casino/AsciiArt.java @@ -0,0 +1,9 @@ +package io.zipcoder.casino; + +import java.awt.*; +import java.awt.image.BufferedImage; + +public class AsciiArt { + + +} diff --git a/src/main/java/io/zipcoder/casino/Displays.java b/src/main/java/io/zipcoder/casino/Displays.java new file mode 100644 index 000000000..0f3cf26cf --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Displays.java @@ -0,0 +1,74 @@ +package io.zipcoder.casino; + +import java.util.Scanner; + +public class Displays { + + public static String getStringInput() { + Scanner scanner = new Scanner(System.in); + String userInput = scanner.nextLine(); + return userInput; + } + + public static void print(String output, Object... args) { + System.out.printf(output, args); + } + + public static void println(String output, Object... args) { + print(output + "\n", args); + } + + public void welcomeScreen() { + println(" "); + println(" $$ $$ "); + println(" $$$$$$$$$$$$$ "); + println(" $$$$$$$$$$$$$$$ "); + println(" $$$ $$ $$ $$$$ "); + println(" $$$ $$ $$ $$$ "); + println(" $$$ $$ $$ "); + println(" $$$$ $$ $$ "); + println(" $$$$$$$$$$$$$ "); + println(" $$$$$$$$$$$$$ "); + println(" $$ $$ $$$$ "); + println(" $$ $$ $$$ "); + println(" $$$ $$ $$ $$$ "); + println(" $$$$ $$ $$ $$$$ "); + println(" $$$$$$$$$$$$$$$ "); + println(" $$$$$$$$$$$$ "); + println(" $$ $$ "); + println(" "); + println(" Welcome to The ZCW Casino!!! "); + println("------------------------------"); + println(" Enter Casino: 00 "); + println(" Leave Casino: 99 "); + } + + public void invalidEntryWelcomeScreen() { + println(" "); + println(" Invalid Entry. Try again "); + println("------------------------------"); + println(" Enter Casino: 00 "); + println(" Leave Casino: 99 "); + } + + public void goodbyeCasinoScreen() { + println(" "); + println(" Have a wonderful day! "); + println(" Come again soon! "); + println(" "); + } + + public void casinoLobbyScreen() { + println(" "); + println(" May the odds be "); + println(" ever in your favor! "); + println("------------------------------"); + println(" Teller Window: 1 "); + println(" *GoFish Room: 2 "); + println(" BlackJack Room: 3 "); + println(" Craps Room: 4 "); + println(" Poker Dice Room: 5 "); + println(" "); + println(" *Don't need chips to play "); + } +} From 5be9a128d0b96b9d50b01611ac08d0e0ff497c2e Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Tue, 16 Mar 2021 15:09:00 -0400 Subject: [PATCH 23/73] finished BlackJack --- .../java/io/zipcoder/casino/BlackJack.java | 50 ++++-- .../io/zipcoder/casino/BlackJackTest.java | 165 +++++++++++++++++- 2 files changed, 197 insertions(+), 18 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index 5df1d206d..4aaa1a244 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -5,13 +5,13 @@ public class BlackJack extends CardGame { Player currentPlayer; + public List playerHand = new ArrayList<>(); + public List dealerHand = new ArrayList<>(); public List playerSplitHand = new ArrayList<>(); - public List dealerSplitHand = new ArrayList<>(); - public int currentTurn = 1; + public List currentHand = playerHand; public int playerTotal; public int playerSplitTotal; public int dealerTotal; - public int dealerSplitTotal; public int sizeOfPot; public BlackJack(Player currentPlayer) { @@ -34,12 +34,22 @@ public void playerBlackJack() { } public void hitMe() { - dealCards(currentTurn); - playerTotal += playerHand.get(playerHand.size()-1).getValue(); + dealCards(currentHand); + if(currentHand == playerHand) { + playerTotal += playerHand.get(playerHand.size() - 1).getValue(); + } else if(currentHand == playerSplitHand) { + playerSplitTotal += playerSplitHand.get(playerSplitHand.size() - 1).getValue(); + } else if(currentHand == dealerHand) { + dealerTotal += dealerHand.get(dealerHand.size() - 1).getValue(); + } } public void hold() { - currentTurn = 2; + currentHand = dealerHand; + } + + public void splitHold() { + currentHand = playerSplitHand; } @Override @@ -47,9 +57,9 @@ public void playGame() { makeDeck(); shuffleDeck(); for(int i = 0; i < 2; i++) { - dealCards(1); + dealCards(playerHand); playerTotal += playerHand.get(i).getValue(); - dealCards(2); + dealCards(dealerHand); dealerTotal += dealerHand.get(i).getValue(); } } @@ -65,16 +75,26 @@ public Boolean checkWinner() { else return null; } + public Boolean checkSplitWinner() { + if(playerSplitTotal == 21 && dealerTotal != 21) return true; + else if(playerSplitTotal > dealerTotal && playerSplitTotal <= 21) return true; + else if(dealerTotal > 21) return true; + else if(playerSplitTotal > 21) return false; + else if(dealerTotal == 21 && playerSplitTotal != 21) return false; + else if (dealerTotal > playerSplitTotal) return false; + else return null; + } + public void playerHandSplit() { + addToPot(sizeOfPot); + playerTotal -= playerHand.get(0).getValue(); playerSplitHand.add(playerHand.remove(0)); playerSplitTotal += playerSplitHand.get(0).getValue(); - } - - public void dealerHandSplit() { - dealerTotal -= dealerHand.get(0).getValue(); - dealerSplitHand.add(dealerHand.remove(0)); - dealerSplitTotal += dealerSplitHand.get(0).getValue(); - } + dealCards(playerHand); + playerTotal += playerHand.get(1).getValue(); + dealCards(playerSplitHand); + playerSplitTotal += playerSplitHand.get(1).getValue(); + } } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 340cbe96d..47d9fec14 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -218,7 +218,7 @@ public void hitMePlayerTest() { } @Test - public void hitMeDealerTest() { + public void hitMeDealerAndHoldTest() { //Given: bj.playGame(); @@ -234,11 +234,170 @@ public void hitMeDealerTest() { } @Test - public void playerHandSplit() { + public void playerHandSplitTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerHand.add(AceOfHearts); + + //When: + bj.playerHandSplit(); + int expected = 2; + int actual = bj.playerHand.size(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerHandSplitPlayerValueTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerTotal += 11; + bj.playerHand.add(AceOfHearts); + bj.playerTotal += 11; + + //When: + bj.playerHandSplit(); + int actual = bj.playerTotal; + + //Then: + assertTrue(actual > 11); + } + + @Test + public void playerHandSplitSecondHandTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerHand.add(AceOfHearts); + + //When: + bj.playerHandSplit(); + int expected = 2; + int actual = bj.playerSplitHand.size(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerHandSplitPlayerSplitValueTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerTotal += 11; + bj.playerHand.add(AceOfHearts); + bj.playerTotal += 11; + + //When: + bj.playerHandSplit(); + int actual = bj.playerSplitTotal; + + //Then: + assertTrue(actual > 11); + } + + @Test + public void playerHandSplitHitMeTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerTotal += 11; + bj.playerHand.add(AceOfHearts); + bj.playerTotal += 11; + + //When: + bj.playerHandSplit(); + bj.hitMe(); + bj.hitMe(); + int actual = bj.playerHand.size(); + + //Then: + assertTrue(actual == 4); + } + + @Test + public void playerHandSplitHitMeOnSplitHandTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerTotal += 11; + bj.playerHand.add(AceOfHearts); + bj.playerTotal += 11; + + //When: + bj.playerHandSplit(); + bj.hitMe(); + bj.splitHold(); + bj.hitMe(); + bj.hitMe(); + bj.hitMe(); + int actual = bj.playerSplitHand.size(); + + //Then: + assertTrue(actual == 5); } @Test - public void dealerHandSplit() { + public void playerHandSplitSizeOfPotTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerTotal += 11; + bj.playerHand.add(AceOfHearts); + bj.playerTotal += 11; + bj.sizeOfPot = 50; + + //When: + bj.playerHandSplit(); + int actual = bj.sizeOfPot; + + //Then: + assertTrue(actual == 100); } + @Test + public void playerHandSplitPlayerChipTest() { + //Given: + Card AceOfHearts=new Card("A", "Hearts", 11); + Card AceOfDiamonds=new Card("A", "Diamonds", 11); + bj.makeDeck(); + bj.shuffleDeck(); + bj.playerHand.add(AceOfDiamonds); + bj.playerTotal += 11; + bj.playerHand.add(AceOfHearts); + bj.playerTotal += 11; + bj.sizeOfPot = 50; + gerg.setChipBalance(5000); + + //When: + bj.playerHandSplit(); + int actual = gerg.getChipBalance(); + + //Then: + assertTrue(actual == 4950); + } } \ No newline at end of file From d1fcb71d93f8c377b177d739953a26c8e4ffb35c Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 15:10:14 -0400 Subject: [PATCH 24/73] working on teller screen --- .../java/io/zipcoder/casino/Displays.java | 37 +++++++++++++++++-- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Displays.java b/src/main/java/io/zipcoder/casino/Displays.java index 0f3cf26cf..4976d8518 100644 --- a/src/main/java/io/zipcoder/casino/Displays.java +++ b/src/main/java/io/zipcoder/casino/Displays.java @@ -19,12 +19,12 @@ public static void println(String output, Object... args) { } public void welcomeScreen() { - println(" "); - println(" $$ $$ "); + println(" "); + println(" $$ $$ "); println(" $$$$$$$$$$$$$ "); println(" $$$$$$$$$$$$$$$ "); - println(" $$$ $$ $$ $$$$ "); - println(" $$$ $$ $$ $$$ "); + println(" $$$ $$ $$ $$$$ "); + println(" $$$ $$ $$ $$$ "); println(" $$$ $$ $$ "); println(" $$$$ $$ $$ "); println(" $$$$$$$$$$$$$ "); @@ -41,6 +41,7 @@ public void welcomeScreen() { println("------------------------------"); println(" Enter Casino: 00 "); println(" Leave Casino: 99 "); + println(" "); } public void invalidEntryWelcomeScreen() { @@ -49,6 +50,7 @@ public void invalidEntryWelcomeScreen() { println("------------------------------"); println(" Enter Casino: 00 "); println(" Leave Casino: 99 "); + println(" "); } public void goodbyeCasinoScreen() { @@ -70,5 +72,32 @@ public void casinoLobbyScreen() { println(" Poker Dice Room: 5 "); println(" "); println(" *Don't need chips to play "); + println(" "); + } + + public void casinoLobbyInvalidScreen() { + println(" "); + println(" Invalid input "); + println(" "); + println("------------------------------"); + println(" Teller Window: 1 "); + println(" *GoFish Room: 2 "); + println(" BlackJack Room: 3 "); + println(" Craps Room: 4 "); + println(" Poker Dice Room: 5 "); + println(" "); + println(" *Don't need chips to play "); + println(" "); + } + + public void tellerWindowScreen() { + println(" /&&&&&&&&/,,,,,,(&@&@@@@@@ "); + println(" &&&&,,,,,,,,,,,,,,,,,,,,,,,,,,&@@@@ "); + println(" &&@&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@@&. "); + println(" &@&*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,/@@@ "); + println(" &@&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@&, "); + println(" @@&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@@ "); + println(" &@,,,,,,,,,,,,,,,,@@@&,,,,,,,,,,,,,,&@@&,,,,,,,,,,,,,,,,@@@ "); + println(" %&&,,,,,,,,,,,,,,,,@@@@@@,,,,,,,,,,,,@@@@@@,,,,,,,,,,,,,,,,@@@ \n"); } } From 85b9bc8b6862441b8b8478fa1fd6de7c407e3c1d Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 15:15:42 -0400 Subject: [PATCH 25/73] teller screen added --- src/main/java/io/zipcoder/casino/Displays.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Displays.java b/src/main/java/io/zipcoder/casino/Displays.java index 4976d8518..2522fe932 100644 --- a/src/main/java/io/zipcoder/casino/Displays.java +++ b/src/main/java/io/zipcoder/casino/Displays.java @@ -91,13 +91,13 @@ public void casinoLobbyInvalidScreen() { } public void tellerWindowScreen() { - println(" /&&&&&&&&/,,,,,,(&@&@@@@@@ "); - println(" &&&&,,,,,,,,,,,,,,,,,,,,,,,,,,&@@@@ "); - println(" &&@&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@@&. "); - println(" &@&*,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,/@@@ "); - println(" &@&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,@@&, "); - println(" @@&,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,&@@ "); - println(" &@,,,,,,,,,,,,,,,,@@@&,,,,,,,,,,,,,,&@@&,,,,,,,,,,,,,,,,@@@ "); - println(" %&&,,,,,,,,,,,,,,,,@@@@@@,,,,,,,,,,,,@@@@@@,,,,,,,,,,,,,,,,@@@ \n"); + println(" "); + println(" How much money would "); + println(" you like to exchange? "); + println(" --------------------- "); + println(" $1 = 1 Chip "); + println(" "); + } + } From 2118050170d1dd9be0f690c88223fc40d720cf49 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Tue, 16 Mar 2021 16:26:54 -0400 Subject: [PATCH 26/73] override toString in Card --- src/main/java/io/zipcoder/casino/Card.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/io/zipcoder/casino/Card.java b/src/main/java/io/zipcoder/casino/Card.java index 6622e5031..cb9595c31 100644 --- a/src/main/java/io/zipcoder/casino/Card.java +++ b/src/main/java/io/zipcoder/casino/Card.java @@ -25,4 +25,9 @@ public Integer getValue(){ public String getCardSuit(){ return cardSuit; } + + @Override + public String toString() { + return String.format("%s of %s", cardName, cardSuit); + } } From 14eb2a8cd13286f2b8c163ceb9975a867cc56975 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 16:50:44 -0400 Subject: [PATCH 27/73] made a Display super class with some subclasses for casino lobby, craps room, and the teller --- src/main/java/io/zipcoder/casino/Casino.java | 7 +- .../java/io/zipcoder/casino/CrapsScreens.java | 105 ++++++++++++++++ .../casino/DisplayMainCasinoScreens.java | 117 ++++++++++++++++++ .../java/io/zipcoder/casino/Displays.java | 82 ------------ 4 files changed, 228 insertions(+), 83 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/CrapsScreens.java create mode 100644 src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 7b7187539..29e249117 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -1,11 +1,16 @@ package io.zipcoder.casino; +import io.zipcoder.casino.utilities.Console; + public class Casino { public static void main(String[] args) { - // write your tests before you start + Casino casino = new Casino(); + casino.run(); } public void run() { + CrapsScreens crapsScreens = new CrapsScreens(); + crapsScreens.crapsWelcomeScreen(); } } diff --git a/src/main/java/io/zipcoder/casino/CrapsScreens.java b/src/main/java/io/zipcoder/casino/CrapsScreens.java new file mode 100644 index 000000000..1b0f1a6bf --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CrapsScreens.java @@ -0,0 +1,105 @@ +package io.zipcoder.casino; + +public class CrapsScreens extends Displays { + //WELCOME + public void crapsWelcomeScreen() { + println(" "); + println(" HHHHH "); + println(" H((((HHH "); + println(" (H((((((((HHX "); + println(" HH((((((HHHHXXX "); + println(" XHH((HHHHHHXXXXX "); + println(" HH((HHHHHHHXXXXXXXX "); + println(" XHHHHHHHHXXXXXXXXXXHH((HHX "); + println(" ,XHXXXXXXXXXXXXXHH((((HHHHHX "); + println(" X,......,HHHH((((H,.... .,X "); + println(" HHH. @@@@ .(((HHHH. @@@@ .HHH "); + println(" HH((( @@@@@@ .HHHXX. @@@@@@ *HHHX "); + println(" XHHHHH. @@@@& HXXXXXX *@@@@ .HHHXXX "); + println(" XXXXXXX. .XHHHH((((. .XXXXXXX "); + println(" XHHHHHHHHHH(((((((((HHHHHHHHXXXXXXXXXHHH "); + println(" HH((((((((((((///////////////////XXXXXHHH(HHHXX "); + println(" HHHHHHHHHHHHHHHHH. ,XXXXHH(((HHHHXXXXX "); + println("XXHHHHHHHHHHHHXXXXXXXXX,..,*XXXXHHH((((HHHHXXXXXXXX "); + println(" XXXXXXXXXXXXXXXXXXXXXXXXXHHHH(((((HHHHXXXXXXXXXXX "); + println(" XXXXXXXXXXXXXXXXHHHHHHHHHHHHHHHXXXXXXXXXXXXX& "); + println(" "); + println(" ARE YOU READY TO PLAY SOME CRAPS? "); + println(" Y or N "); + println(" "); + } + + public void crapsInvalidWelcomeScreen() { + println(" "); + println(" Invalid Entry "); + println(" ------------- "); + println(" ARE YOU READY TO PLAY SOME CRAPS? "); + println(" Y or N "); + println(" "); + } + + //ROUND ONE + public void passOrNotPassScreen(int roundOfGame) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" How are you betting? "); + println(" -------------------- "); + println(" 1: Pass "); + println(" 2: Not Pass "); + println(" "); + } + + public void betAmountScreen(int roundOfGame) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" How much are you betting? "); + println(" ------------------------- "); + println(" "); + } + + public void winRollScreen(int roundOfGame, int pot, int sumOfDice, String betStatus) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" Bet Status: %s ", betStatus); + println(" "); + println(" Chips in Pot: %s ", pot); + println(" "); + println(" You rolled a %s ", sumOfDice); + println(" --------------- "); + println(" You Win! "); + println(" "); + } + + public void loseRollScreen(int roundOfGame, int pot, int sumOfDice, String betStatus) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" Bet Status: %s ", betStatus); + println(" "); + println(" Chips in Pot: %s ", pot); + println(" "); + println(" You rolled a %s ", sumOfDice); + println(" --------------- "); + println(" You Lose... "); + println(" "); + } + + public void playAgainScreen() { + println(" "); + println(" Play Again? "); + println(" ----------- "); + println(" Y or N "); + println(" "); + } + + public void leaveCrapsScreen() { + println(" "); + println(" Good Luck! "); + println(" "); + } +} + + diff --git a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java new file mode 100644 index 000000000..50badccca --- /dev/null +++ b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java @@ -0,0 +1,117 @@ +package io.zipcoder.casino; + +public class DisplayMainCasinoScreens extends Displays{ + + //MAIN SCREEN + public void welcomeScreen() { + println(" "); + println(" $$ $$ "); + println(" $$$$$$$$$$$$$ "); + println(" $$$$$$$$$$$$$$$ "); + println(" $$$ $$ $$ $$$$ "); + println(" $$$ $$ $$ $$$ "); + println(" $$$ $$ $$ "); + println(" $$$$ $$ $$ "); + println(" $$$$$$$$$$$$$ "); + println(" $$$$$$$$$$$$$ "); + println(" $$ $$ $$$$ "); + println(" $$ $$ $$$ "); + println(" $$$ $$ $$ $$$ "); + println(" $$$$ $$ $$ $$$$ "); + println(" $$$$$$$$$$$$$$$ "); + println(" $$$$$$$$$$$$ "); + println(" $$ $$ "); + println(" "); + println(" Welcome to The ZCW Casino!!! "); + println("------------------------------"); + println(" 00: Enter Casino "); + println(" 99: Leave Casino "); + println(" "); + } + + public void invalidEntryWelcomeScreen() { + println(" "); + println(" Invalid Entry. Try again "); + println("------------------------------"); + println(" 00: Enter Casino "); + println(" 99: Leave Casino "); + println(" "); + } + + public void goodbyeCasinoScreen() { + println(" "); + println(" Have a wonderful day! "); + println(" Come again soon! "); + println(" "); + } + + //CASINO LOBBY + public void casinoLobbyScreen() { + println(" "); + println(" May the odds be "); + println(" ever in your favor! "); + println("------------------------------"); + println(" 1: Teller Window "); + println(" 2: *GoFish Room "); + println(" 3: BlackJack Room "); + println(" 4: Craps Room "); + println(" 5: Poker Dice Room "); + println(" "); + println(" *Don't need chips to play "); + println(" "); + } + + public void casinoLobbyInvalidScreen() { + println(" "); + println(" Invalid input "); + println(" "); + println("------------------------------"); + println(" 1: Teller Window "); + println(" 2: *GoFish Room "); + println(" 3: BlackJack Room "); + println(" 4: Craps Room "); + println(" 5: Poker Dice Room "); + println(" "); + println(" *Don't need chips to play "); + println(" "); + } + + //TELLER + public void tellerMainScreen() { + println(" "); + println(" How may I help you? "); + println(" ------------------- "); + println(" 1: Exchange money "); + println(" 2: Cash Out "); + println(" "); + } + + public void tellerInvalidMainScreen() { + println(" "); + println(" I don't understand... "); + println(" Please choose an option "); + println(" from the menu below "); + println(" ------------------- "); + println(" 1: Exchange money "); + println(" 2: Cash Out "); + println(" "); + } + + public void tellerMoneyToChipsScreen() { + println(" "); + println(" How much money would "); + println(" you like to exchange? "); + println(" --------------------- "); + println(" $1 = 1 Chip "); + println(" "); + } + + public void tellerChipsToMoneyScreen(int numOfPlayerChips) { + println(" "); + println(" You cashed out: "); + println(" $%s ",numOfPlayerChips); + println(" --------------------- "); + println(" 1: Another transaction "); + println(" 2: Exit "); + } +} diff --git a/src/main/java/io/zipcoder/casino/Displays.java b/src/main/java/io/zipcoder/casino/Displays.java index 2522fe932..bf40bfc44 100644 --- a/src/main/java/io/zipcoder/casino/Displays.java +++ b/src/main/java/io/zipcoder/casino/Displays.java @@ -18,86 +18,4 @@ public static void println(String output, Object... args) { print(output + "\n", args); } - public void welcomeScreen() { - println(" "); - println(" $$ $$ "); - println(" $$$$$$$$$$$$$ "); - println(" $$$$$$$$$$$$$$$ "); - println(" $$$ $$ $$ $$$$ "); - println(" $$$ $$ $$ $$$ "); - println(" $$$ $$ $$ "); - println(" $$$$ $$ $$ "); - println(" $$$$$$$$$$$$$ "); - println(" $$$$$$$$$$$$$ "); - println(" $$ $$ $$$$ "); - println(" $$ $$ $$$ "); - println(" $$$ $$ $$ $$$ "); - println(" $$$$ $$ $$ $$$$ "); - println(" $$$$$$$$$$$$$$$ "); - println(" $$$$$$$$$$$$ "); - println(" $$ $$ "); - println(" "); - println(" Welcome to The ZCW Casino!!! "); - println("------------------------------"); - println(" Enter Casino: 00 "); - println(" Leave Casino: 99 "); - println(" "); - } - - public void invalidEntryWelcomeScreen() { - println(" "); - println(" Invalid Entry. Try again "); - println("------------------------------"); - println(" Enter Casino: 00 "); - println(" Leave Casino: 99 "); - println(" "); - } - - public void goodbyeCasinoScreen() { - println(" "); - println(" Have a wonderful day! "); - println(" Come again soon! "); - println(" "); - } - - public void casinoLobbyScreen() { - println(" "); - println(" May the odds be "); - println(" ever in your favor! "); - println("------------------------------"); - println(" Teller Window: 1 "); - println(" *GoFish Room: 2 "); - println(" BlackJack Room: 3 "); - println(" Craps Room: 4 "); - println(" Poker Dice Room: 5 "); - println(" "); - println(" *Don't need chips to play "); - println(" "); - } - - public void casinoLobbyInvalidScreen() { - println(" "); - println(" Invalid input "); - println(" "); - println("------------------------------"); - println(" Teller Window: 1 "); - println(" *GoFish Room: 2 "); - println(" BlackJack Room: 3 "); - println(" Craps Room: 4 "); - println(" Poker Dice Room: 5 "); - println(" "); - println(" *Don't need chips to play "); - println(" "); - } - - public void tellerWindowScreen() { - println(" "); - println(" How much money would "); - println(" you like to exchange? "); - println(" --------------------- "); - println(" $1 = 1 Chip "); - println(" "); - - } - } From ddd5a05892032f951c497c22371fa1c50ef7d773 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 16:53:21 -0400 Subject: [PATCH 28/73] took stuff out of casino that I was testing --- src/main/java/io/zipcoder/casino/Casino.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 29e249117..8620bdb34 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -5,12 +5,10 @@ public class Casino { public static void main(String[] args) { - Casino casino = new Casino(); - casino.run(); + } public void run() { - CrapsScreens crapsScreens = new CrapsScreens(); - crapsScreens.crapsWelcomeScreen(); + } } From 7de5a4137b155710a4c6f748779fd5074129089c Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Tue, 16 Mar 2021 17:07:06 -0400 Subject: [PATCH 29/73] ALMOST DONE --- src/main/java/io/zipcoder/casino/GoFish.java | 76 ++++++- .../java/io/zipcoder/casino/GoFishTest.java | 213 +++++++++++++++++- 2 files changed, 282 insertions(+), 7 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index 58b606d18..c61ad29bb 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -6,22 +6,96 @@ public class GoFish extends CardGame { private List oswald= new ArrayList<>(); private List dealer= new ArrayList<>(); + private List books=new ArrayList(); + int playerScore=0; + int dealerScore=0; public void playGame() { + } public Boolean checkWinner() { return null; } + public void turnStructure(){ + + } + public Integer cardsInHand(List player){ return player.size(); } - public String showCard(List player, int indexOfCard) { String name=player.get(indexOfCard).getCardName(); String suit=player.get(indexOfCard).getCardSuit(); return name+" of "+suit; } + + public String seeHand(List player){ + String wholeHand="Your hand is:\n"; + for(int i=0; i hand, String name) { + for(Card i:hand){ + if(name.equals(i.getCardName())){ + return true; + } + } + return false; + } + + public void takeCards(ArrayList taker, ArrayList taken, String name) { + for(int i=0;i player, String name) { + if(name.equals(player.get(player.size()-1).getCardName())){ + return true; + } + return false; + } + + public String showBooks(){ + String temp=""; + for(String i:books){ + temp=temp.concat(i+", "); + } + return temp; + } + + public Boolean completeSet(ArrayList player, String name) { + int first=0; + int second=0; + int third=0; + int fourth=0; + int nameFound=0; + for (int i=0;i oswald= new ArrayList<>(); + ArrayList dealer= new ArrayList<>(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + Integer actual=friendlyGame.cardsInHand(dealer); + Integer expected = 2; + Assert.assertEquals(actual,expected); + } - - + @Test + public void testShowCard(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + String actual=friendlyGame.showCard(oswald, 3); + String expected="4 of Spades"; + Assert.assertEquals(actual,expected); + } + @Test + public void testSeeHand(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + String actual=friendlyGame.seeHand(oswald); + String expected="Your hand is:\nA of Spades\n2 of Spades\n3 of Spades\n4 of Spades\n"; + Assert.assertEquals(actual,expected); + } @Test - public void testShowCard(){ + public void testGotAnyKings1(){ GoFish friendlyGame=new GoFish(); + friendlyGame.makeDeck(); ArrayList oswald= new ArrayList<>(); + ArrayList dealer= new ArrayList<>(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(dealer); + Assert.assertTrue(friendlyGame.gotAnyKings(oswald, "A")); + + } + + @Test + public void testTakeCards(){ + GoFish friendlyGame=new GoFish(); friendlyGame.makeDeck(); + ArrayList oswald= new ArrayList<>(); + ArrayList dealer= new ArrayList<>(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); friendlyGame.dealCards(oswald); friendlyGame.dealCards(oswald); friendlyGame.dealCards(oswald); friendlyGame.dealCards(oswald); friendlyGame.dealCards(oswald); - //String actual=friendlyGame.showCard(); - //String expected="4 of Spades"; - //Assert.assertEquals(actual,expected); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + + friendlyGame.takeCards(oswald,dealer,"2"); + + Integer actual=friendlyGame.cardsInHand(dealer); + Integer expected = 9; + Assert.assertEquals(actual,expected); } + @Test + public void testTakeCards2(){ + GoFish friendlyGame=new GoFish(); + friendlyGame.makeDeck(); + ArrayList oswald= new ArrayList<>(); + ArrayList dealer= new ArrayList<>(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + friendlyGame.dealCards(dealer); + + friendlyGame.takeCards(oswald,dealer,"4"); + Integer actual=friendlyGame.cardsInHand(oswald); + Integer expected = 11; + Assert.assertEquals(actual,expected); + } + @Test + public void testDrawAnyKings(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + Assert.assertTrue(friendlyGame.drawAnyKings(oswald, "A")); + } + @Test + public void testDrawAnyKings2(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + Assert.assertFalse(friendlyGame.drawAnyKings(oswald, "A")); + } + @Test + public void testDrawAnyKings3(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + Assert.assertTrue(friendlyGame.drawAnyKings(oswald, "2")); + } + @Test + public void testDrawAnyKings4(){ + GoFish friendlyGame=new GoFish(); + ArrayList oswald= new ArrayList<>(); + friendlyGame.makeDeck(); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //A + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //2 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //3 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //4 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //5 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //6 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //7 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //8 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //9 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //10 + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //J + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //Q + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + friendlyGame.dealCards(oswald); + //K + Assert.assertTrue(friendlyGame.completeSet(oswald, "K")); + } } From 210acfec311c5ccb02a70dc582f2565923757aba Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Tue, 16 Mar 2021 18:45:30 -0400 Subject: [PATCH 30/73] added initialize players in PlayerWarehouse and started on BlackJack story --- .../io/zipcoder/casino/BlackJackEngine.java | 101 ++++++++++++++++++ .../io/zipcoder/casino/PlayerWarehouse.java | 12 ++- 2 files changed, 112 insertions(+), 1 deletion(-) create mode 100644 src/main/java/io/zipcoder/casino/BlackJackEngine.java diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java new file mode 100644 index 000000000..dacc40c86 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -0,0 +1,101 @@ +package io.zipcoder.casino; + +import io.zipcoder.casino.utilities.Console; + +public class BlackJackEngine { + + public static void main(String[] args) { + BlackJackEngine bj = new BlackJackEngine(); + + bj.blackJack(); + } + + public void blackJack() { + boolean gameOn = true; + Console console = new Console(System.in, System.out); + PlayerWarehouse.initializePlayers(); + Player player = PlayerWarehouse.currentPlayers.get(100); + BlackJack bj = new BlackJack(player); + player.setChipBalance(5000); + + + System.out.println("Welcome To BlackJack!"); + + while(gameOn) { + Integer input = console.getIntegerInput("Up for a game? 1 - Yes or 2 - No"); + + boolean validInput = true; + while(validInput) { + switch (input) { + case 1: + Integer bet = console.getIntegerInput("What is your bet?"); + boolean invalidBet = bet > player.getChipBalance(); + //check for Player chip balance + if(invalidBet) { + System.out.println("Balance not enough, please lower your bet or enter 0 to cancel"); + break; + } else if (bet == 0) { + blackJack(); + validInput = false; + break; + } + bj.addToPot(bet); + validInput = false; + break; + case 2: + System.out.println("Good bye!"); + gameOn = false; + break; + default: + input = console.getIntegerInput("Not a valid input. Please choose 1 or 2"); + break; + } + } + + bj.playGame(); + + + currentHands(bj); + boolean round = true; + while(round) + input = console.getIntegerInput("\nWhat would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); + switch (input) { + case 1: + bj.hitMe(); + currentHands(bj); + break; + case 2: + bj.hold(); + currentHands(bj); + break; + case 3: + bj.playerHandSplit(); + currentHands(bj); + round = false; +// if(bj.playerHand.get(0).getCardName().equals(bj.playerHand.get(1))) { +// bj.playerHandSplit(); +// } else input = console.getIntegerInput("Not a pair, cannot split. Please select a valid action"); + break; + default: + System.out.println("Not a valid input"); + break; + } + + + + } + + } + + public void currentHands(BlackJack blackJack) { + System.out.println(String.format("Dealer current hand: %s\n",blackJack.dealerTotal)); + System.out.println(String.format("=== %s ===", blackJack.dealerHand)); + if(!blackJack.playerSplitHand.isEmpty()) { + System.out.println(String.format("\nPlayer current split hand: %s\n", blackJack.playerSplitTotal)); + System.out.println(String.format("=== %s ===", blackJack.playerSplitHand)); + } + System.out.println(String.format("\nPlayer current hand: %s\n", blackJack.playerTotal)); + System.out.println(String.format("=== %s ===", blackJack.playerHand)); + } +} + diff --git a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java index f6a224b17..2d9ab8cae 100644 --- a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java +++ b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java @@ -4,7 +4,17 @@ import java.util.Map; public class PlayerWarehouse { - private static Map currentPlayers = new HashMap<>(); + public static Map currentPlayers = new HashMap<>(); + + public static void initializePlayers() { + Player gerg = PlayerFactory.createPlayer("Greg", 5000); + Player nixog = PlayerFactory.createPlayer("Xiong", 5000); + Player eab = PlayerFactory.createPlayer("Abe", 5000); + + currentPlayers.put(100, nixog); + currentPlayers.put(200, gerg); + currentPlayers.put(300, eab); + } public static void addPlayer(int playerID, Player player) { currentPlayers.put(playerID, player); From 6030d4758e2886bcc4c19e11073fd058cb92f4a8 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Tue, 16 Mar 2021 22:01:33 -0400 Subject: [PATCH 31/73] MOAK and Craps screens all made. Added insufficientChips screen to Displays superclass --- .../java/io/zipcoder/casino/CrapsScreens.java | 71 ++++++++++- .../java/io/zipcoder/casino/Displays.java | 9 ++ .../zipcoder/casino/MostOfAKindScreens.java | 116 ++++++++++++++++++ 3 files changed, 193 insertions(+), 3 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/MostOfAKindScreens.java diff --git a/src/main/java/io/zipcoder/casino/CrapsScreens.java b/src/main/java/io/zipcoder/casino/CrapsScreens.java index 1b0f1a6bf..7a2ae225e 100644 --- a/src/main/java/io/zipcoder/casino/CrapsScreens.java +++ b/src/main/java/io/zipcoder/casino/CrapsScreens.java @@ -38,8 +38,8 @@ public void crapsInvalidWelcomeScreen() { println(" "); } - //ROUND ONE - public void passOrNotPassScreen(int roundOfGame) { + //ROUND ONE PREP + public void passOrNotPassRoundOneScreen(int roundOfGame) { println(" "); println(" ROUND: %s ", roundOfGame); println(" "); @@ -50,7 +50,7 @@ public void passOrNotPassScreen(int roundOfGame) { println(" "); } - public void betAmountScreen(int roundOfGame) { + public void betAmountRoundOneScreen(int roundOfGame) { println(" "); println(" ROUND: %s ", roundOfGame); println(" "); @@ -59,6 +59,52 @@ public void betAmountScreen(int roundOfGame) { println(" "); } + public void rollTheDice() { + println(" "); + println(" Enter 1 to roll dice "); + println(" "); + } + + + //ROUND TWO SCREENS + public void passOrNotPassRoundTwoScreen(int roundOfGame, int pot, int sumOfDice, String betStatus, int pointer) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" Bet Status: %s ", betStatus); + println(" "); + println(" Chips in pot: %s ", pot); + println(" "); + println(" Pointer: %s ", pointer); + println(" "); + println(" Your roll: %s ", sumOfDice); + println(" "); + println(" How are you betting? "); + println(" -------------------- "); + println(" 1: Pass "); + println(" 2: Not Pass "); + println(" "); + } + + public void betAmountRoundTwoScreen(int roundOfGame, String betStatus, int pot, int pointer, int sumOfDice) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" Bet Status: %s ", betStatus); + println(" "); + println(" Chips in pot: %s ", pot); + println(" "); + println(" Pointer: %s ", pointer); + println(" "); + println(" Your roll: %s ", sumOfDice); + println(" "); + println(" How much are you betting? "); + println(" ------------------------- "); + println(" "); + } + + + //OUTCOME OPTIONS public void winRollScreen(int roundOfGame, int pot, int sumOfDice, String betStatus) { println(" "); println(" ROUND: %s ", roundOfGame); @@ -87,6 +133,25 @@ public void loseRollScreen(int roundOfGame, int pot, int sumOfDice, String betSt println(" "); } + public void rollAgainScreen(int roundOfGame, int pot, int sumOfDice, String betStatus, int pointer) { + println(" "); + println(" ROUND: %s ", roundOfGame); + println(" "); + println(" Bet Status: %s ", betStatus); + println(" "); + println(" Chips in Pot: %s ", pot); + println(" "); + println(" You rolled a %s ", sumOfDice); + println(" "); + println(" Pointer: %s ", pointer); + println(" --------------- "); + println(" Roll again! "); + println(" Enter 1 "); + println(" "); + } + + + //ENDING SCREENS public void playAgainScreen() { println(" "); println(" Play Again? "); diff --git a/src/main/java/io/zipcoder/casino/Displays.java b/src/main/java/io/zipcoder/casino/Displays.java index bf40bfc44..b59ac9b50 100644 --- a/src/main/java/io/zipcoder/casino/Displays.java +++ b/src/main/java/io/zipcoder/casino/Displays.java @@ -18,4 +18,13 @@ public static void println(String output, Object... args) { print(output + "\n", args); } + public void notEnoughMoneyScreen() { + println(" "); + println("You don't have enough chips"); + println(" "); + println(" 00: Return and try again "); + println(" "); + + } + } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java b/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java new file mode 100644 index 000000000..059738220 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java @@ -0,0 +1,116 @@ +package io.zipcoder.casino; + +import java.util.ArrayList; + +public class MostOfAKindScreens extends Displays{ + //WELCOME + public void welcomeMoakScreen() { + println(" "); + println(" Welcome to the MOAK Room! "); + println(" ------------------------- "); + println(" Would you like to play? "); + println(" "); + println(" Y or N "); + println(" "); + } + + public void welcomeInvalidMoakScreen() { + println(" "); + println(" Invalid Input "); + println(" ------------------------- "); + println(" Would you like to play? "); + println(" "); + println(" Y or N "); + println(" "); + } + + public void anteUpScreen() { + println(" "); + println(" Time to ante up! "); + println(" "); + println(" 1: Pays and rolls "); + println(" "); + } + + //FIRST ROLL + public void firstRollScreen(int pot, ArrayList playerDice) { + println(" "); + println(" Current pot: %s ", pot); + println(" "); + println(" Your Dice: "); + println("%s ", playerDice); + println(" "); + println("How much do you want to bet? "); + println(" "); + } + + public void numberToKeepScreen(int pot, ArrayList playerDice) { + println(" "); + println(" Current pot: %s ", pot); + println(" "); + println(" Your Dice: "); + println("%s ", playerDice); + println(" "); + println("Which number do you want to keep?"); + println(" "); + } + + //SECOND ROLL + public void secondRollScreen(int pot, ArrayList playerDice) { + println(" "); + println(" Current pot: %s ", pot); + println(" "); + println(" Your Dice: "); + println("%s ", playerDice); + println(" "); + println("How much do you want to bet? "); + println(" "); + } + + //FINAL STEP + public void revealHandsPlayerWins(int pot, ArrayList playerDice, ArrayList dealerDice) { + println(" "); + println(" Current pot: %s ", pot); + println(" "); + println(" Your Dice: "); + println("%s ", playerDice); + println(" "); + println(" Dealer's Dice: "); + println("%s ", dealerDice); + println(" "); + println(" YOU WIN! "); + } + + public void revealHandsDealerWins(int pot, ArrayList playerDice, ArrayList dealerDice) { + println(" "); + println(" Current pot: %s ", pot); + println(" "); + println(" Your Dice: "); + println("%s ", playerDice); + println(" "); + println(" Dealer's Dice: "); + println("%s ", dealerDice); + println(" "); + println(" House wins "); + println(" "); + } + + + //PLAY AGAIN + public void playAgainScreen() { + println(" "); + println(" Do you want to play again? "); + println(" "); + println(" Y or N "); + println(" "); + } + + public void goodbyeScreen() { + println(" "); + println(" Good Luck! "); + println(" "); + } + + + +} From 3785682efa8fa1194c84fb26447fa9ef285d64e3 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Tue, 16 Mar 2021 23:56:38 -0400 Subject: [PATCH 32/73] added checks for blackjack and busts + wrote tests --- .../java/io/zipcoder/casino/BlackJack.java | 27 ++- .../io/zipcoder/casino/BlackJackEngine.java | 169 ++++++++------ .../io/zipcoder/casino/BlackJackTest.java | 212 +++++++++++++++++- 3 files changed, 343 insertions(+), 65 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index 4aaa1a244..7e4ae64bb 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -28,7 +28,7 @@ public void playerWinPot() { sizeOfPot = 0; } - public void playerBlackJack() { + public void playerWinByBlackJack() { currentPlayer.winChips(sizeOfPot*3); sizeOfPot = 0; } @@ -97,4 +97,29 @@ public void playerHandSplit() { dealCards(playerSplitHand); playerSplitTotal += playerSplitHand.get(1).getValue(); } + + public boolean playerHaveBlackJack() { + return playerTotal == 21; + } + + public boolean playerSplitHandHaveBlackJack() { + return playerSplitTotal == 21; + } + + public boolean dealerHaveBlackJack() { + return dealerTotal == 21; + } + + public boolean playerBust() { + return playerTotal > 21; + } + + public boolean playerSplitHandBust() { + return playerSplitTotal > 21; + } + + public boolean dealerBust() { + return dealerTotal > 21; + } + } diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index dacc40c86..deb30da8f 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -18,84 +18,127 @@ public void blackJack() { BlackJack bj = new BlackJack(player); player.setChipBalance(5000); - + System.out.println(String.format("Hello %s", player.getPlayerName())); System.out.println("Welcome To BlackJack!"); - while(gameOn) { - Integer input = console.getIntegerInput("Up for a game? 1 - Yes or 2 - No"); - - boolean validInput = true; - while(validInput) { - switch (input) { - case 1: - Integer bet = console.getIntegerInput("What is your bet?"); - boolean invalidBet = bet > player.getChipBalance(); - //check for Player chip balance - if(invalidBet) { - System.out.println("Balance not enough, please lower your bet or enter 0 to cancel"); - break; - } else if (bet == 0) { - blackJack(); - validInput = false; - break; - } - bj.addToPot(bet); - validInput = false; - break; - case 2: - System.out.println("Good bye!"); - gameOn = false; - break; - default: - input = console.getIntegerInput("Not a valid input. Please choose 1 or 2"); - break; - } - } - - bj.playGame(); + while (gameOn) { + mainBlackJackMenu(bj, player, console); +// String choice = console.getStringInput("Would you like to play again? Yes/No"); +// while(true) { +// if(choice.equalsIgnoreCase("yes")) { +// continue; +// } else if (choice.equalsIgnoreCase("no")) { +// System.out.println("Good bye!"); +// gameOn = false; +// } else choice = console.getStringInput("Please choose yes or no"); +// break; +// } + } + } - currentHands(bj); - boolean round = true; - while(round) - input = console.getIntegerInput("\nWhat would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); - switch (input) { - case 1: - bj.hitMe(); - currentHands(bj); - break; - case 2: - bj.hold(); - currentHands(bj); - break; - case 3: - bj.playerHandSplit(); - currentHands(bj); - round = false; -// if(bj.playerHand.get(0).getCardName().equals(bj.playerHand.get(1))) { -// bj.playerHandSplit(); -// } else input = console.getIntegerInput("Not a pair, cannot split. Please select a valid action"); + public void mainBlackJackMenu(BlackJack bj, Player player, Console console) { + + boolean validInput = true; + while(validInput) { + Integer input = console.getIntegerInput("Play? 1 - Yes or 2 - No"); + switch (input) { + case 1: + currentChipCount(player); + Integer bet = console.getIntegerInput("What is your bet?"); + boolean invalidBet = bet > player.getChipBalance(); + if(invalidBet) { + System.out.println("Balance not enough, please lower your bet or enter 0 to cancel"); break; - default: - System.out.println("Not a valid input"); + } else if (bet == 0) { + mainBlackJackMenu(bj, player, console); + validInput = false; break; - } - - - + } + bj.addToPot(bet); + bj.playGame(); + roundStart(bj, player, console); + validInput = false; + break; + case 2: + System.out.println("Good bye!"); + validInput = false; + break; + default: + System.out.println("Not a valid input. Please choose 1 or 2"); + break; + } } - } + + public void currentHands(BlackJack blackJack) { System.out.println(String.format("Dealer current hand: %s\n",blackJack.dealerTotal)); - System.out.println(String.format("=== %s ===", blackJack.dealerHand)); + System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.dealerHand)); if(!blackJack.playerSplitHand.isEmpty()) { System.out.println(String.format("\nPlayer current split hand: %s\n", blackJack.playerSplitTotal)); - System.out.println(String.format("=== %s ===", blackJack.playerSplitHand)); + System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.playerSplitHand)); } System.out.println(String.format("\nPlayer current hand: %s\n", blackJack.playerTotal)); - System.out.println(String.format("=== %s ===", blackJack.playerHand)); + System.out.println(String.format("\t\t\t\t\t=== %s ===\n", blackJack.playerHand)); + } + + public void currentChipCount(Player player) { + System.out.println(String.format("%s : Your current chip count is %7d", player.getPlayerName(), player.getChipBalance())); + } + + + public void roundStart(BlackJack blackJack, Player player, Console console) { + System.out.println(String.format("Hello %s", player.getPlayerName())); + boolean round = true; + while(round) { + currentHands(blackJack); + currentChipCount(player); + Integer decision = console.getIntegerInput("\nWhat would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); + switch (decision) { + case 1: + blackJack.hitMe(); + break; + case 2: + blackJack.hold(); + if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { + if(blackJack.checkWinner() == true) { + System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot)); + blackJack.playerWinPot(); + resetHandAndValues(blackJack); + round = false; + } else if (blackJack.checkWinner() == false) { + System.out.println("Sorry better luck next time!"); + blackJack.sizeOfPot = 0; + resetHandAndValues(blackJack); + round = false; + } + } + break; + case 3: + if(blackJack.playerHand.get(0).getCardName().equals(blackJack.playerHand.get(1))) { + blackJack.playerHandSplit(); + } else if (!blackJack.playerSplitHand.isEmpty()) { + System.out.println("Already split! Cannot split again!"); + } else System.out.println("Not a pair, cannot split. Please select a valid action"); + break; + default: + System.out.println("Not a valid input"); + break; + } + } } + + public void resetHandAndValues(BlackJack blackJack) { + blackJack.discardHand(blackJack.playerHand); + blackJack.discardHand(blackJack.playerSplitHand); + blackJack.discardHand(blackJack.dealerHand); + blackJack.playerTotal = 0; + blackJack.playerSplitTotal = 0; + blackJack.dealerTotal = 0; + } + + } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 47d9fec14..163532339 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -74,7 +74,7 @@ public void playerBlackJackTest() { //When: bj.addToPot(500); - bj.playerBlackJack(); + bj.playerWinByBlackJack(); int expected = 4000; int actual = gerg.getChipBalance(); @@ -400,4 +400,214 @@ public void playerHandSplitPlayerChipTest() { //Then: assertTrue(actual == 4950); } + + @Test + public void checkSplitWinnerTrueTest() { + //Given: + bj.playerSplitTotal = 21; + bj.dealerTotal = 20; + + //When: + boolean expected = true; + boolean actual = bj.checkSplitWinner(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void checkSplitWinnerFalseTest() { + //Given: + bj.playerSplitTotal = 18; + bj.dealerTotal = 19; + + //When: + boolean expected = false; + boolean actual = bj.checkSplitWinner(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void checkSplitWinnerTieTest() { + //Given: + bj.playerSplitTotal = 17; + bj.dealerTotal = 17; + + //When: + Boolean expected = null; + Boolean actual = bj.checkSplitWinner(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerHaveBlackJackTrueTest() { + //Given: + bj.playerTotal = 21; + bj.dealerTotal = 20; + + //When: + boolean expected = true; + boolean actual = bj.playerHaveBlackJack(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerHaveBlackJackFalseTest() { + //Given: + bj.playerTotal = 18; + bj.dealerTotal = 20; + + //When: + boolean expected = false; + boolean actual = bj.playerHaveBlackJack(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerSplitHandHaveBlackJackTrueTest() { + //Given: + bj.playerSplitTotal = 21; + bj.dealerTotal = 18; + + //When: + boolean expected = true; + boolean actual = bj.playerSplitHandHaveBlackJack(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerSplitHandHaveBlackJackFalseTest() { + //Given: + bj.playerSplitTotal = 16; + bj.dealerTotal = 18; + + //When: + boolean expected = false; + boolean actual = bj.playerSplitHandHaveBlackJack(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void dealerHaveBlackJackTrueTest() { + //Given: + bj.playerTotal = 20; + bj.dealerTotal = 21; + + //When: + boolean expected = true; + boolean actual = bj.dealerHaveBlackJack(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void dealerHaveBlackJackFalseTest() { + //Given: + bj.playerTotal = 20; + bj.dealerTotal = 18; + + //When: + boolean expected = false; + boolean actual = bj.dealerHaveBlackJack(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerBustTrueTest() { + //Given: + bj.playerTotal = 23; + bj.dealerTotal = 18; + + //When: + boolean expected = true; + boolean actual = bj.playerBust(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerBustFalseTest() { + //Given: + bj.playerTotal = 20; + bj.dealerTotal = 19; + + //When: + boolean expected = false; + boolean actual = bj.playerBust(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerSplitHandBustTrueTest() { + //Given: + bj.playerSplitTotal = 24; + bj.dealerTotal = 19; + + //When: + boolean expected = true; + boolean actual = bj.playerSplitHandBust(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void playerSplitHandBustFalseTest() { + //Given: + bj.playerSplitTotal = 15; + bj.dealerTotal = 19; + + //When: + boolean expected = false; + boolean actual = bj.playerSplitHandBust(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void dealerBustTrueTest() { + //Given: + bj.playerSplitTotal = 20; + bj.dealerTotal = 26; + + //When: + boolean expected = true; + boolean actual = bj.dealerBust(); + + //Then: + assertEquals(expected, actual); + } + + @Test + public void dealerBustFalseTest() { + //Given: + bj.playerSplitTotal = 20; + bj.dealerTotal = 13; + + //When: + boolean expected = false; + boolean actual = bj.dealerBust(); + + //Then: + assertEquals(expected, actual); + } } \ No newline at end of file From 95d0b91dc1dee08a4cb613d64afc7efa5b8b9ee2 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Wed, 17 Mar 2021 01:27:30 -0400 Subject: [PATCH 33/73] updated BlackJack game --- .../java/io/zipcoder/casino/BlackJack.java | 15 +++++- .../io/zipcoder/casino/BlackJackEngine.java | 52 +++++++++++++++++-- .../io/zipcoder/casino/BlackJackTest.java | 15 ++++++ 3 files changed, 76 insertions(+), 6 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index 7e4ae64bb..b6265f492 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -8,7 +8,7 @@ public class BlackJack extends CardGame { public List playerHand = new ArrayList<>(); public List dealerHand = new ArrayList<>(); public List playerSplitHand = new ArrayList<>(); - public List currentHand = playerHand; + public List currentHand = playerHand; public int playerTotal; public int playerSplitTotal; public int dealerTotal; @@ -26,11 +26,24 @@ public void addToPot(int chipsAdded) { public void playerWinPot() { currentPlayer.winChips(sizeOfPot*2); sizeOfPot = 0; + currentHand = playerHand; + } + + public void tiedPot() { + currentPlayer.winChips(sizeOfPot); + sizeOfPot = 0; + currentHand = playerHand; } public void playerWinByBlackJack() { currentPlayer.winChips(sizeOfPot*3); sizeOfPot = 0; + currentHand = playerHand; + } + + public void playerLosePot() { + sizeOfPot = 0; + currentHand = playerHand; } public void hitMe() { diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index deb30da8f..3785217bf 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -85,7 +85,7 @@ public void currentHands(BlackJack blackJack) { } public void currentChipCount(Player player) { - System.out.println(String.format("%s : Your current chip count is %7d", player.getPlayerName(), player.getChipBalance())); + System.out.println(String.format("%s : Your current chip count is %7d\n", player.getPlayerName(), player.getChipBalance())); } @@ -95,22 +95,42 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { while(round) { currentHands(blackJack); currentChipCount(player); - Integer decision = console.getIntegerInput("\nWhat would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); + currentTurnIndicator(blackJack); + Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); switch (decision) { case 1: blackJack.hitMe(); + if(blackJack.playerBust()) { + currentHands(blackJack); + System.out.println("BUST! Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetHandAndValues(blackJack); + round = false; + } + if(blackJack.dealerBust()) { + currentHands(blackJack); + System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", blackJack.sizeOfPot)); + blackJack.playerWinPot(); + resetHandAndValues(blackJack); + round = false; + } break; case 2: blackJack.hold(); if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { if(blackJack.checkWinner() == true) { - System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot)); + System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot*2)); blackJack.playerWinPot(); resetHandAndValues(blackJack); round = false; } else if (blackJack.checkWinner() == false) { - System.out.println("Sorry better luck next time!"); - blackJack.sizeOfPot = 0; + System.out.println("Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetHandAndValues(blackJack); + round = false; + } else if (blackJack.checkWinner() == null) { + System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); + blackJack.tiedPot(); resetHandAndValues(blackJack); round = false; } @@ -139,6 +159,28 @@ public void resetHandAndValues(BlackJack blackJack) { blackJack.dealerTotal = 0; } + public void currentTurnIndicator(BlackJack blackJack) { + if(blackJack.currentHand == blackJack.playerHand || blackJack.currentHand == blackJack.playerSplitHand) { + System.out.println(String.format("Turn to act : *** %s ***", blackJack.currentPlayer.getPlayerName())); + } else if(blackJack.currentHand == blackJack.dealerHand) { + System.out.println("Turn to act : *** Dealer ***"); + } + } + + public String bustChecker(BlackJack blackJack) { + if(blackJack.playerBust()) { + System.out.println("Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetHandAndValues(blackJack); + return "Bust"; + } else if(blackJack.dealerBust()) { + System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot)); + blackJack.playerWinPot(); + resetHandAndValues(blackJack); + return "Bust"; + } else return "Good"; + } + } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 163532339..c88df47c1 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -610,4 +610,19 @@ public void dealerBustFalseTest() { //Then: assertEquals(expected, actual); } + + @Test + public void tiePotTest() { + //Given: + gerg.setChipBalance(3000); + + //When: + bj.addToPot(500); + bj.tiedPot(); + int expected = 3000; + int actual = gerg.getChipBalance(); + + //Then: + assertEquals(expected, actual); + } } \ No newline at end of file From 2a36e776b5ab09121021c1163c754e47fa78fc24 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Wed, 17 Mar 2021 09:22:23 -0400 Subject: [PATCH 34/73] changed checkwinner for you Xiong --- src/main/java/io/zipcoder/casino/Game.java | 2 +- src/main/java/io/zipcoder/casino/GoFish.java | 111 +++++++++++++++++-- 2 files changed, 105 insertions(+), 8 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Game.java b/src/main/java/io/zipcoder/casino/Game.java index e69fec54c..87c142a69 100644 --- a/src/main/java/io/zipcoder/casino/Game.java +++ b/src/main/java/io/zipcoder/casino/Game.java @@ -4,5 +4,5 @@ public interface Game { public void playGame(); - public Boolean checkWinner(); + public String checkWinner(); } diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index c61ad29bb..86ba4b1b1 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -6,20 +6,117 @@ public class GoFish extends CardGame { private List oswald= new ArrayList<>(); private List dealer= new ArrayList<>(); + Player currentplayer; private List books=new ArrayList(); int playerScore=0; int dealerScore=0; + + public GoFish(Player current){ + currentplayer=current; + makeDeck(); + shuffleDeck(); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + } + + //blank constructor, mostly to make tests easier. + public GoFish(){ + makeDeck(); + shuffleDeck(); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + } + public void playGame() { + System.out.println("Welcome to Go Fish, "+currentplayer.getPlayerName()); + System.out.println("This is a nice, friendly game so don't worry about " + + "the chips, okay?"); + for(int i=0; i<7;i++){ + if (completeSet(oswald, oswald.get(0).getCardName())){ + playerScore++; + } + if (completeSet(dealer, dealer.get(0).getCardName())){ + dealerScore++; + } + } + if(playerScore>0||dealerScore>0){ + System.out.println("We already have some books! Crazy!");} } - public Boolean checkWinner() { - return null; + public String checkWinner() { + if(dealerScore>playerScore){return "Dealer wins! Sorry....";} + else return "You win! Congrats!"; } + + + public void turnStructure(){ - + Boolean legalchoice=false; + Boolean takeAnotherTurn=true; + String input=""; + while (takeAnotherTurn) { + System.out.println("Alright, Go fish!"); + takeAnotherTurn=false; + legalchoice=false; + input=""; + while (!legalchoice) { + input = Displays.getStringInput(); + legalchoice = true; + if (!gotAnyKings(oswald, input)) { + System.out.println("You can only pick card names you have in hand"); + legalchoice = false; + } + } + if (gotAnyKings(dealer, input)) { + System.out.println("You caught fish!"); + takeCards(oswald, dealer, input); + takeAnotherTurn=true; + System.out.println("You caught a fish! You get another turn!"); + if(completeSet(oswald, input)){ + playerScore++; + System.out.println("Congrats, you closed a book!"); + } + } else { + System.out.println("Whoops! No bites, better draw!"); + dealCards(oswald); + if(completeSet(oswald, oswald.get(oswald.size()-1).getCardName())){ + playerScore++; + System.out.println("Congrats, you closed a book!"); + } + if(drawAnyKings(oswald,input)){ + takeAnotherTurn=true; + System.out.println("You caught a fish! You get another turn!"); + } + } + } + System.out.println("Turn over!"); } public Integer cardsInHand(List player){ @@ -40,7 +137,7 @@ public String seeHand(List player){ return wholeHand; } - public Boolean gotAnyKings(ArrayList hand, String name) { + public Boolean gotAnyKings(List hand, String name) { for(Card i:hand){ if(name.equals(i.getCardName())){ return true; @@ -49,7 +146,7 @@ public Boolean gotAnyKings(ArrayList hand, String name) { return false; } - public void takeCards(ArrayList taker, ArrayList taken, String name) { + public void takeCards(List taker, List taken, String name) { for(int i=0;i taker, ArrayList taken, String name) } } - public Boolean drawAnyKings(ArrayList player, String name) { + public Boolean drawAnyKings(List player, String name) { if(name.equals(player.get(player.size()-1).getCardName())){ return true; } @@ -73,7 +170,7 @@ public String showBooks(){ return temp; } - public Boolean completeSet(ArrayList player, String name) { + public Boolean completeSet(List player, String name) { int first=0; int second=0; int third=0; From 2e77c9d6ac459d7d5956a986a03dcc981f89fd22 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Wed, 17 Mar 2021 10:18:46 -0400 Subject: [PATCH 35/73] updated initializePlayers and added deck reset in blackjack engine --- .../io/zipcoder/casino/BlackJackEngine.java | 21 +++++-------------- .../io/zipcoder/casino/PlayerWarehouse.java | 3 +++ 2 files changed, 8 insertions(+), 16 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 3785217bf..51f8ab1e9 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -16,7 +16,6 @@ public void blackJack() { PlayerWarehouse.initializePlayers(); Player player = PlayerWarehouse.currentPlayers.get(100); BlackJack bj = new BlackJack(player); - player.setChipBalance(5000); System.out.println(String.format("Hello %s", player.getPlayerName())); System.out.println("Welcome To BlackJack!"); @@ -105,6 +104,7 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { System.out.println("BUST! Sorry, better luck next time!"); blackJack.playerLosePot(); resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); round = false; } if(blackJack.dealerBust()) { @@ -112,6 +112,7 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", blackJack.sizeOfPot)); blackJack.playerWinPot(); resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); round = false; } break; @@ -122,16 +123,19 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot*2)); blackJack.playerWinPot(); resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); round = false; } else if (blackJack.checkWinner() == false) { System.out.println("Sorry, better luck next time!"); blackJack.playerLosePot(); resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); round = false; } else if (blackJack.checkWinner() == null) { System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); blackJack.tiedPot(); resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); round = false; } } @@ -167,20 +171,5 @@ public void currentTurnIndicator(BlackJack blackJack) { } } - public String bustChecker(BlackJack blackJack) { - if(blackJack.playerBust()) { - System.out.println("Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetHandAndValues(blackJack); - return "Bust"; - } else if(blackJack.dealerBust()) { - System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot)); - blackJack.playerWinPot(); - resetHandAndValues(blackJack); - return "Bust"; - } else return "Good"; - } - - } diff --git a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java index 2d9ab8cae..e7f15c8e7 100644 --- a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java +++ b/src/main/java/io/zipcoder/casino/PlayerWarehouse.java @@ -10,6 +10,9 @@ public static void initializePlayers() { Player gerg = PlayerFactory.createPlayer("Greg", 5000); Player nixog = PlayerFactory.createPlayer("Xiong", 5000); Player eab = PlayerFactory.createPlayer("Abe", 5000); + gerg.setChipBalance(5000); + nixog.setChipBalance(5000); + eab.setChipBalance(5000); currentPlayers.put(100, nixog); currentPlayers.put(200, gerg); From 0c1df073efc4e19457c5e708d1595203c5945b23 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 11:00:24 -0400 Subject: [PATCH 36/73] screens and ish --- src/main/java/io/zipcoder/casino/Craps.java | 19 ++-- .../java/io/zipcoder/casino/CrapsEngine.java | 87 +++++++++++++++++++ .../java/io/zipcoder/casino/CrapsScreens.java | 6 +- .../java/io/zipcoder/casino/CrapsTest.java | 26 ++---- 4 files changed, 108 insertions(+), 30 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/CrapsEngine.java diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java index e223955c9..179967bcf 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -2,11 +2,17 @@ public class Craps extends DiceGame { int gameRound = 1; - String betStatus; + StringBuffer betStatus = new StringBuffer("hi"); + Player currentPlayer; Integer[] roundOnePass = new Integer[]{7, 11}; Integer[] roundOneNotPass = new Integer[]{2, 3, 12}; Integer[] rollAgain = new Integer[]{4, 5, 6, 8, 9, 10}; int pointer; + int currentSum; + + public Craps(Player currentPlayer) { + this.currentPlayer = currentPlayer; + } public void addToPot(int numOfChips) { pot += numOfChips; @@ -82,12 +88,12 @@ public int checkWinnerRoundTwo(int sumOfDice) { return outcome; } - public int sumOfDice() { + public void sumOfDice() { int sum = 0; for (int i = 0; i < 2; i++) { sum += rollDice(); } - return sum; + currentSum = sum; } public void setGameRound(int round) { @@ -106,11 +112,12 @@ public int getPointer() { return this.pointer; } - public void setBetStatus(String betStatus) { - this.betStatus = betStatus; + public void setBetStatus(String status) { + betStatus.replace(0, betStatus.length(), ""); + betStatus.append(status); } public String getBetStatus() { - return this.betStatus; + return betStatus.toString(); } } diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java new file mode 100644 index 000000000..f3c21141b --- /dev/null +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -0,0 +1,87 @@ +package io.zipcoder.casino; + +import com.sun.tools.javac.util.Assert; +import io.zipcoder.casino.utilities.Console; + +public class CrapsEngine { + Console console = new Console(System.in, System.out); + //boolean gameOn = true; + //PlayerWarehouse pWare = new PlayerWarehouse(); + CrapsScreens cScreens = new CrapsScreens(); + Player player = new Player("gerg", 500); + Craps craps = new Craps(player); + + + + public static void main(String[] args) { + CrapsEngine craps = new CrapsEngine(); + craps.startCrapsGame(); + } + + private void startCrapsGame() { + cScreens.crapsWelcomeScreen(); + player.setChipBalance(100); + while (true) { + Integer input = console.getIntegerInput(""); + if (input.equals(1)) { + passOrNotPassRoundOneScreen(craps.getGameRound()); + } else if (input.equals(2)) { + casinoLobby(); + } else { + crapsInvalidWelcomeScreen(); + } + } + } + + private void crapsInvalidWelcomeScreen() { + cScreens.crapsInvalidWelcomeScreen(); + } + + //TEMPORARY + private void casinoLobby() { + System.exit(0); + } + + private void passOrNotPassRoundOneScreen(int gameRound) { + cScreens.passOrNotPassRoundOneScreen(craps.getGameRound()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input.equals(1)) { + craps.setBetStatus("Pass"); + betAmountRoundOneScreen(); + } else if (input.equals(2)) { + craps.setBetStatus("Not Pass"); + betAmountRoundOneScreen(); + } else { + System.out.println("Please enter 1 or 2"); + } + } + } + + private void betAmountRoundOneScreen() { + cScreens.betAmountRoundOneScreen(craps.getGameRound()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input < player.getChipBalance()) { + craps.addToPot(input); + rollTheDice(); + } else { + System.out.println("Insufficient Chips"); + } + } + } + + private void rollTheDice() { + cScreens.rollTheDice(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + if (craps.betStatus.equals("Pass") && craps.currentSum == 7 || craps.currentSum == 11) { + + } + } + } + } + + +} diff --git a/src/main/java/io/zipcoder/casino/CrapsScreens.java b/src/main/java/io/zipcoder/casino/CrapsScreens.java index 7a2ae225e..92d7633de 100644 --- a/src/main/java/io/zipcoder/casino/CrapsScreens.java +++ b/src/main/java/io/zipcoder/casino/CrapsScreens.java @@ -25,7 +25,7 @@ public void crapsWelcomeScreen() { println(" XXXXXXXXXXXXXXXXHHHHHHHHHHHHHHHXXXXXXXXXXXXX& "); println(" "); println(" ARE YOU READY TO PLAY SOME CRAPS? "); - println(" Y or N "); + println(" 1: Yes 2: No "); println(" "); } @@ -34,7 +34,7 @@ public void crapsInvalidWelcomeScreen() { println(" Invalid Entry "); println(" ------------- "); println(" ARE YOU READY TO PLAY SOME CRAPS? "); - println(" Y or N "); + println(" 1: Yes 2: No "); println(" "); } @@ -156,7 +156,7 @@ public void playAgainScreen() { println(" "); println(" Play Again? "); println(" ----------- "); - println(" Y or N "); + println(" 1: Yes 2: No "); println(" "); } diff --git a/src/test/java/io/zipcoder/casino/CrapsTest.java b/src/test/java/io/zipcoder/casino/CrapsTest.java index ee21e2624..35f6d622e 100644 --- a/src/test/java/io/zipcoder/casino/CrapsTest.java +++ b/src/test/java/io/zipcoder/casino/CrapsTest.java @@ -4,12 +4,13 @@ import org.junit.Test; public class CrapsTest { + Player gerg = PlayerFactory.createPlayer("gerg", 500); + Craps craps = new Craps(gerg); //SuperClass tests @Test public void getPot() { //Given - Craps craps = new Craps(); int expected = 0; //When @@ -22,7 +23,6 @@ public void getPot() { @Test public void addToPot() { //Given - Craps craps = new Craps(); int expected = 5; //When @@ -36,7 +36,6 @@ public void addToPot() { @Test public void clearPot() { //Given - Craps craps = new Craps(); int expected = 0; craps.addToPot(7); craps.clearPot(); @@ -51,7 +50,6 @@ public void clearPot() { @Test public void rollDice() { //Given - Craps craps = new Craps(); //When int result = craps.rollDice(); @@ -65,7 +63,6 @@ public void rollDice() { @Test public void setGameRound() { //Given - Craps craps = new Craps(); int expected = 1; //When @@ -79,7 +76,6 @@ public void setGameRound() { @Test public void setGetPointer() { //Given - Craps craps = new Craps(); int expected = 8; //When @@ -93,7 +89,6 @@ public void setGetPointer() { @Test public void setGetBetStatus() { //Given - Craps craps = new Craps(); String expected = "Pass"; //When @@ -107,10 +102,11 @@ public void setGetBetStatus() { @Test public void sumOfDice() { //Given - Craps craps = new Craps(); //When - int actual = craps.sumOfDice(); + craps.sumOfDice(); + int actual = craps.currentSum; + //Then Assert.assertTrue(actual > 1 && actual < 13); @@ -120,7 +116,6 @@ public void sumOfDice() { @Test public void playerWinsRoundOnePass() { //Given - Craps craps = new Craps(); int expected = 1; craps.setBetStatus("Pass"); @@ -135,7 +130,6 @@ public void playerWinsRoundOnePass() { @Test public void playerLosesRoundOnePass() { //Given - Craps craps = new Craps(); int expected = 2; craps.setBetStatus("Pass"); @@ -150,7 +144,6 @@ public void playerLosesRoundOnePass() { @Test public void playerRollsAgainPass() { //Given - Craps craps = new Craps(); int expected = 3; craps.setBetStatus("Pass"); @@ -166,7 +159,6 @@ public void playerRollsAgainPass() { @Test public void playerWinsRoundOneNotPass() { //Given - Craps craps = new Craps(); int expected = 1; craps.setBetStatus("Not Pass"); @@ -181,7 +173,6 @@ public void playerWinsRoundOneNotPass() { @Test public void playerLosesRoundOneNotPass() { //Given - Craps craps = new Craps(); int expected = 2; craps.setBetStatus("Not Pass"); @@ -196,7 +187,6 @@ public void playerLosesRoundOneNotPass() { @Test public void playerRollsAgainRoundOneNotPass() { //Given - Craps craps = new Craps(); int expected = 3; craps.setBetStatus("Not Pass"); @@ -212,7 +202,6 @@ public void playerRollsAgainRoundOneNotPass() { @Test public void playerWinsRoundTwoPass() { //Given - Craps craps = new Craps(); int expected = 1; craps.setBetStatus("Pass"); craps.setPointer(10); @@ -228,7 +217,6 @@ public void playerWinsRoundTwoPass() { @Test public void playerLosesRoundTwoPass() { //Given - Craps craps = new Craps(); int expected = 2; craps.setBetStatus("Pass"); craps.setPointer(10); @@ -244,7 +232,6 @@ public void playerLosesRoundTwoPass() { @Test public void playerRollsAgainRoundTwoPass() { //Given - Craps craps = new Craps(); int expected = 3; craps.setBetStatus("Pass"); craps.setPointer(10); @@ -261,7 +248,6 @@ public void playerRollsAgainRoundTwoPass() { @Test public void playerWinsRoundTwoNotPass() { //Given - Craps craps = new Craps(); int expected = 1; craps.setBetStatus("Not Pass"); craps.setPointer(10); @@ -277,7 +263,6 @@ public void playerWinsRoundTwoNotPass() { @Test public void playerLosesRoundTwoNotPass() { //Given - Craps craps = new Craps(); int expected = 2; craps.setBetStatus("Not Pass"); craps.setPointer(10); @@ -293,7 +278,6 @@ public void playerLosesRoundTwoNotPass() { @Test public void playerRollsAgainRoundTwoNotPass() { //Given - Craps craps = new Craps(); int expected = 3; craps.setBetStatus("Not Pass"); craps.setPointer(10); From 8063ee7d6f15acd0d203616427b7e6377153d289 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Wed, 17 Mar 2021 11:03:11 -0400 Subject: [PATCH 37/73] changed gameWinner checks on BlackJack --- .../java/io/zipcoder/casino/BlackJack.java | 36 +++++++-------- .../io/zipcoder/casino/BlackJackEngine.java | 10 ++-- .../io/zipcoder/casino/BlackJackTest.java | 46 ++++++++++++------- 3 files changed, 53 insertions(+), 39 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index b6265f492..d6601aacf 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -78,24 +78,24 @@ public void playGame() { } @Override - public Boolean checkWinner() { - if(playerTotal == 21 && dealerTotal != 21) return true; - else if(playerTotal > dealerTotal && playerTotal <= 21) return true; - else if(dealerTotal > 21) return true; - else if(playerTotal > 21) return false; - else if(dealerTotal == 21 && playerTotal != 21) return false; - else if (dealerTotal > playerTotal) return false; - else return null; - } - - public Boolean checkSplitWinner() { - if(playerSplitTotal == 21 && dealerTotal != 21) return true; - else if(playerSplitTotal > dealerTotal && playerSplitTotal <= 21) return true; - else if(dealerTotal > 21) return true; - else if(playerSplitTotal > 21) return false; - else if(dealerTotal == 21 && playerSplitTotal != 21) return false; - else if (dealerTotal > playerSplitTotal) return false; - else return null; + public String checkWinner() { + if(playerTotal == 21 && dealerTotal != 21) return "Player"; + else if(playerTotal > dealerTotal && playerTotal <= 21) return "Player"; + else if(dealerTotal > 21) return "Player"; + else if(playerTotal > 21) return "Dealer"; + else if(dealerTotal == 21 && playerTotal != 21) return "Dealer"; + else if (dealerTotal > playerTotal) return "Dealer"; + else return "Tie"; + } + + public String checkSplitWinner() { + if(playerSplitTotal == 21 && dealerTotal != 21) return "Player"; + else if(playerSplitTotal > dealerTotal && playerSplitTotal <= 21) return "Player"; + else if(dealerTotal > 21) return "Player"; + else if(playerSplitTotal > 21) return "Dealer"; + else if(dealerTotal == 21 && playerSplitTotal != 21) return "Dealer"; + else if (dealerTotal > playerSplitTotal) return "Dealer"; + else return "Tie"; } public void playerHandSplit() { diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 51f8ab1e9..734280638 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -109,7 +109,7 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { } if(blackJack.dealerBust()) { currentHands(blackJack); - System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", blackJack.sizeOfPot)); + System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); blackJack.playerWinPot(); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); @@ -119,19 +119,19 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { case 2: blackJack.hold(); if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { - if(blackJack.checkWinner() == true) { - System.out.println(String.format("Congrats! You won %s chips.", blackJack.sizeOfPot*2)); + if(blackJack.checkWinner().equals("Player")) { + System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); blackJack.playerWinPot(); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; - } else if (blackJack.checkWinner() == false) { + } else if (blackJack.checkWinner().equals("Dealer")) { System.out.println("Sorry, better luck next time!"); blackJack.playerLosePot(); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; - } else if (blackJack.checkWinner() == null) { + } else if (blackJack.checkWinner().equals("Tie")) { System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); blackJack.tiedPot(); resetHandAndValues(blackJack); diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index c88df47c1..4104ac9a2 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -139,8 +139,8 @@ public void checkWinnerPlayerWinTest() { bj.dealerTotal = 17; //When: - boolean expected = true; - boolean actual = bj.checkWinner(); + String expected = "Player"; + String actual = bj.checkWinner(); //Then: assertEquals(expected, actual); @@ -153,8 +153,8 @@ public void checkWinnerPlayerBustTest() { bj.dealerTotal = 17; //When: - boolean expected = false; - boolean actual = bj.checkWinner(); + String expected = "Dealer"; + String actual = bj.checkWinner(); //Then: assertEquals(expected, actual); @@ -167,8 +167,8 @@ public void checkWinnerDealerWinsTest() { bj.dealerTotal = 20; //When: - boolean expected = false; - boolean actual = bj.checkWinner(); + String expected = "Dealer"; + String actual = bj.checkWinner(); //Then: assertEquals(expected, actual); @@ -181,8 +181,8 @@ public void checkWinnerDealerBustTest() { bj.dealerTotal = 23; //When: - boolean expected = true; - boolean actual = bj.checkWinner(); + String expected = "Player"; + String actual = bj.checkWinner(); //Then: assertEquals(expected, actual); @@ -195,8 +195,8 @@ public void checkWinnerPlayerBlackJackTest() { bj.dealerTotal = 21; //When: - Boolean expected = null; - Boolean actual = bj.checkWinner(); + String expected = "Tie"; + String actual = bj.checkWinner(); //Then: assertEquals(expected, actual); @@ -408,8 +408,8 @@ public void checkSplitWinnerTrueTest() { bj.dealerTotal = 20; //When: - boolean expected = true; - boolean actual = bj.checkSplitWinner(); + String expected = "Player"; + String actual = bj.checkSplitWinner(); //Then: assertEquals(expected, actual); @@ -422,8 +422,8 @@ public void checkSplitWinnerFalseTest() { bj.dealerTotal = 19; //When: - boolean expected = false; - boolean actual = bj.checkSplitWinner(); + String expected = "Dealer"; + String actual = bj.checkSplitWinner(); //Then: assertEquals(expected, actual); @@ -436,8 +436,8 @@ public void checkSplitWinnerTieTest() { bj.dealerTotal = 17; //When: - Boolean expected = null; - Boolean actual = bj.checkSplitWinner(); + String expected = "Tie"; + String actual = bj.checkSplitWinner(); //Then: assertEquals(expected, actual); @@ -625,4 +625,18 @@ public void tiePotTest() { //Then: assertEquals(expected, actual); } + + @Test + public void checkWinnerTieTest() { + //Given: + bj.playerTotal = 17; + bj.dealerTotal = 17; + + //When: + String expected = "Tie"; + String actual = bj.checkWinner(); + + //Then: + assertEquals(expected, actual); + } } \ No newline at end of file From 2c0b58385ec2af90fb9987bf9a24fd01b68debf4 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 11:25:42 -0400 Subject: [PATCH 38/73] works through rollTheDice screen --- .../java/io/zipcoder/casino/CrapsEngine.java | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index f3c21141b..f2303adf0 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -76,12 +76,34 @@ private void rollTheDice() { while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { + craps.sumOfDice(); if (craps.betStatus.equals("Pass") && craps.currentSum == 7 || craps.currentSum == 11) { - + winRollScreen(); + } else if (craps.betStatus.equals("Not Pass") && craps.currentSum == 2 || craps.currentSum == 3 || craps.currentSum == 12) { + winRollScreen(); + } else if (craps.betStatus.equals("Pass") && craps.currentSum == 2 || craps.currentSum == 3 || craps.currentSum == 12) { + loseRollScreen(); + } else if (craps.betStatus.equals("Not Pass") && craps.currentSum == 7 || craps.currentSum == 11) { + loseRollScreen(); + } else { + craps.setPointer(craps.currentSum); + rollAgainScreen(); } } } } + private void loseRollScreen() { + cScreens.loseRollScreen(craps.getGameRound(), craps.getPot(), craps.currentSum, craps.getBetStatus()); + } + + private void rollAgainScreen() { + cScreens.rollAgainScreen(craps.getGameRound(), craps.getPot(), craps.currentSum, craps.getBetStatus(), craps.getPointer()); + } + + private void winRollScreen() { + cScreens.winRollScreen(craps.getGameRound(), craps.getPot(), craps.currentSum, craps.getBetStatus()); + } + } From b87ad4a7bd5baaa10314285b65ea345a4e62ae1e Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 12:45:35 -0400 Subject: [PATCH 39/73] working my way through crapsEngine --- src/main/java/io/zipcoder/casino/Craps.java | 4 + .../java/io/zipcoder/casino/CrapsEngine.java | 120 +++++++++++++++--- .../java/io/zipcoder/casino/CrapsScreens.java | 58 +++++++-- 3 files changed, 156 insertions(+), 26 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java index 179967bcf..19d655cd4 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -120,4 +120,8 @@ public void setBetStatus(String status) { public String getBetStatus() { return betStatus.toString(); } + + public int getCurrentSum() { + return currentSum; + } } diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index f2303adf0..033317db1 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -43,6 +43,8 @@ private void casinoLobby() { } private void passOrNotPassRoundOneScreen(int gameRound) { + craps.setGameRound(1); + craps.clearPot(); cScreens.passOrNotPassRoundOneScreen(craps.getGameRound()); while (true) { Integer input = console.getIntegerInput(""); @@ -62,7 +64,7 @@ private void betAmountRoundOneScreen() { cScreens.betAmountRoundOneScreen(craps.getGameRound()); while (true) { Integer input = console.getIntegerInput(""); - if (input < player.getChipBalance()) { + if (input < player.getChipBalance() && input >= 0) { craps.addToPot(input); rollTheDice(); } else { @@ -77,33 +79,117 @@ private void rollTheDice() { Integer input = console.getIntegerInput(""); if (input == 1) { craps.sumOfDice(); - if (craps.betStatus.equals("Pass") && craps.currentSum == 7 || craps.currentSum == 11) { - winRollScreen(); - } else if (craps.betStatus.equals("Not Pass") && craps.currentSum == 2 || craps.currentSum == 3 || craps.currentSum == 12) { - winRollScreen(); - } else if (craps.betStatus.equals("Pass") && craps.currentSum == 2 || craps.currentSum == 3 || craps.currentSum == 12) { - loseRollScreen(); - } else if (craps.betStatus.equals("Not Pass") && craps.currentSum == 7 || craps.currentSum == 11) { - loseRollScreen(); - } else { - craps.setPointer(craps.currentSum); - rollAgainScreen(); + if (craps.getBetStatus().equalsIgnoreCase("Pass")) { + if (craps.getCurrentSum() == 7 || craps.getCurrentSum() == 11) { + winRollScreen(); + } else if (craps.getCurrentSum() == 2 || craps.getCurrentSum() == 3 || craps.getCurrentSum() == 12) { + loseRollScreen(); + } else { + craps.setPointer(craps.getCurrentSum()); + rollAgainScreen(); + } + } else if (craps.getBetStatus().equalsIgnoreCase("Not Pass")) { + if (craps.getCurrentSum() == 2 || craps.getCurrentSum() == 3 || craps.getCurrentSum() == 12) { + winRollScreen(); + } else if (craps.getCurrentSum() == 7 || craps.getCurrentSum() == 11) { + loseRollScreen(); + } else { + craps.setPointer(craps.getCurrentSum()); + rollAgainScreen(); + } } + } else { + System.out.println("Invalid Entry"); } } } private void loseRollScreen() { - cScreens.loseRollScreen(craps.getGameRound(), craps.getPot(), craps.currentSum, craps.getBetStatus()); + cScreens.loseRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input.equals(1)) { + craps.setGameRound(1); + passOrNotPassRoundOneScreen(craps.getGameRound()); + } else if (input.equals(2)) { + casinoLobby(); + } else { + System.out.println("Invalid Entry"); + } + } } - private void rollAgainScreen() { - cScreens.rollAgainScreen(craps.getGameRound(), craps.getPot(), craps.currentSum, craps.getBetStatus(), craps.getPointer()); + private void winRollScreen() { + cScreens.winRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input.equals(1)) { + craps.setGameRound(1); + passOrNotPassRoundOneScreen(craps.getGameRound()); + } else if (input.equals(2)) { + casinoLobby(); + } else { + System.out.println("Invalid Entry"); + } + } } - private void winRollScreen() { - cScreens.winRollScreen(craps.getGameRound(), craps.getPot(), craps.currentSum, craps.getBetStatus()); + private void rollAgainScreen() { + cScreens.passOrNotPassRoundTwoScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input.equals(1)) { + craps.setBetStatus("Pass"); + rollAgainBetScreen(); + } else if (input.equals(2)) { + craps.setBetStatus("Not Pass"); + rollAgainBetScreen(); + } else { + System.out.println("Please enter 1 or 2"); + } + } } + private void rollAgainBetScreen() { + cScreens.rollAgainBetScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input < player.getChipBalance() && input >=0) { + craps.addToPot(input); + rollTheDiceOnward(); + } else { + System.out.println("Insufficient Chips"); + } + } + } + private void rollTheDiceOnward() { + craps.setGameRound(2); + cScreens.rollAgainOnward(craps.getGameRound(),craps.getBetStatus(), craps.getPot(), craps.getCurrentSum()); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + craps.sumOfDice(); + if (craps.getBetStatus().equalsIgnoreCase("Pass")) { + if (craps.getCurrentSum() == craps.getPointer()) { + winRollScreen(); + } else if (craps.getCurrentSum() == 7) { + loseRollScreen(); + } else { + rollAgainBetScreen(); + } + } else if (craps.getBetStatus().equalsIgnoreCase("Not Pass")) { + if (craps.getCurrentSum() == 7) { + winRollScreen(); + } else if (craps.getCurrentSum() == craps.getPointer()) { + loseRollScreen(); + } else { + rollAgainBetScreen(); + } + } + } else { + System.out.println("Invalid Entry"); + } + } + } } diff --git a/src/main/java/io/zipcoder/casino/CrapsScreens.java b/src/main/java/io/zipcoder/casino/CrapsScreens.java index 92d7633de..45ca4e2df 100644 --- a/src/main/java/io/zipcoder/casino/CrapsScreens.java +++ b/src/main/java/io/zipcoder/casino/CrapsScreens.java @@ -86,7 +86,24 @@ public void passOrNotPassRoundTwoScreen(int roundOfGame, int pot, int sumOfDice, println(" "); } - public void betAmountRoundTwoScreen(int roundOfGame, String betStatus, int pot, int pointer, int sumOfDice) { +// public void betAmountRoundTwoScreen(int roundOfGame, String betStatus, int pot, int pointer, int sumOfDice) { +// println(" "); +// println(" ROUND: %s ", roundOfGame); +// println(" "); +// println(" Bet Status: %s ", betStatus); +// println(" "); +// println(" Chips in pot: %s ", pot); +// println(" "); +// println(" Pointer: %s ", pointer); +// println(" "); +// println(" Your roll: %s ", sumOfDice); +// println(" "); +// println(" How much are you betting? "); +// println(" ------------------------- "); +// println(" "); +// } + + public void rollAgainOnward(int roundOfGame, String betStatus, int pot, int pointer) { println(" "); println(" ROUND: %s ", roundOfGame); println(" "); @@ -95,11 +112,8 @@ public void betAmountRoundTwoScreen(int roundOfGame, String betStatus, int pot, println(" Chips in pot: %s ", pot); println(" "); println(" Pointer: %s ", pointer); - println(" "); - println(" Your roll: %s ", sumOfDice); - println(" "); - println(" How much are you betting? "); - println(" ------------------------- "); + println(" ------------- "); + println(" Enter 1 to roll dice "); println(" "); } @@ -117,6 +131,9 @@ public void winRollScreen(int roundOfGame, int pot, int sumOfDice, String betSta println(" --------------- "); println(" You Win! "); println(" "); + println(" Play again? "); + println(" 1: Yes 2: No "); + println(" "); } public void loseRollScreen(int roundOfGame, int pot, int sumOfDice, String betStatus) { @@ -131,9 +148,31 @@ public void loseRollScreen(int roundOfGame, int pot, int sumOfDice, String betSt println(" --------------- "); println(" You Lose... "); println(" "); + println(" Play again? "); + println(" 1: Yes 2: No "); + println(" "); } - public void rollAgainScreen(int roundOfGame, int pot, int sumOfDice, String betStatus, int pointer) { +// public void rollAgainScreen(int roundOfGame, int pot, int sumOfDice, String betStatus, int pointer) { +// println(" "); +// println(" ROUND: %s ", roundOfGame); +// println(" "); +// println(" Bet Status: %s ", betStatus); +// println(" "); +// println(" Chips in Pot: %s ", pot); +// println(" "); +// println(" You rolled a %s ", sumOfDice); +// println(" "); +// println(" Pointer: %s ", pointer); +// println(" --------------- "); +// println(" Roll again! "); +// println(" "); +// println(" How are you betting? "); +// println(" ------------------------- "); +// println(" "); +// } + + public void rollAgainBetScreen(int roundOfGame, int pot, int sumOfDice, String betStatus, int pointer) { println(" "); println(" ROUND: %s ", roundOfGame); println(" "); @@ -145,9 +184,10 @@ public void rollAgainScreen(int roundOfGame, int pot, int sumOfDice, String betS println(" "); println(" Pointer: %s ", pointer); println(" --------------- "); - println(" Roll again! "); - println(" Enter 1 "); + println(" How much are you betting? "); + println(" ------------------------- "); println(" "); + } From 68e1711411f23644090341876a88d9dd5ac6dfde Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Wed, 17 Mar 2021 12:49:54 -0400 Subject: [PATCH 40/73] FINISHED blackjack engine and fixed blackjackchecker tests --- .../java/io/zipcoder/casino/BlackJack.java | 15 ++- .../io/zipcoder/casino/BlackJackEngine.java | 120 +++++++++++++++++- .../io/zipcoder/casino/BlackJackTest.java | 26 +++- 3 files changed, 153 insertions(+), 8 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index d6601aacf..e9be9ce3c 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -112,15 +112,24 @@ public void playerHandSplit() { } public boolean playerHaveBlackJack() { - return playerTotal == 21; + if (playerTotal == 21 && (playerHand.get(0).getCardName().equals("A") || playerHand.get(1).getCardName().equals("A"))) { + return true; + } + return false; } public boolean playerSplitHandHaveBlackJack() { - return playerSplitTotal == 21; + if (playerSplitTotal == 21 && (playerSplitHand.get(0).getCardName().equals("A") || playerSplitHand.get(1).getCardName().equals("A"))) { + return true; + } + return false; } public boolean dealerHaveBlackJack() { - return dealerTotal == 21; + if (dealerTotal == 21 && (dealerHand.get(0).getCardName().equals("A") || dealerHand.get(1).getCardName().equals("A"))) { + return true; + } + return false; } public boolean playerBust() { diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 734280638..7742d3f34 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -90,11 +90,33 @@ public void currentChipCount(Player player) { public void roundStart(BlackJack blackJack, Player player, Console console) { System.out.println(String.format("Hello %s", player.getPlayerName())); + boolean round = true; while(round) { currentHands(blackJack); currentChipCount(player); currentTurnIndicator(blackJack); + if(blackJack.playerHaveBlackJack() && blackJack.dealerHaveBlackJack() || blackJack.dealerHaveBlackJack() && blackJack.playerHaveBlackJack()) { + System.out.println(String.format("Both BLACKJACK! You won %s chips.", (blackJack.sizeOfPot))); + blackJack.tiedPot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + break; + } + if(blackJack.playerHaveBlackJack()) { + System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); + blackJack.playerWinByBlackJack(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + break; + } + if(blackJack.dealerHaveBlackJack()) { + System.out.println("Dealer BLACKJACK! Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + break; + } Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); switch (decision) { case 1: @@ -141,8 +163,9 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { } break; case 3: - if(blackJack.playerHand.get(0).getCardName().equals(blackJack.playerHand.get(1))) { - blackJack.playerHandSplit(); + if(blackJack.playerHand.get(0).getCardName().equals(blackJack.playerHand.get(1).getCardName())) { + splitHandStart(blackJack, player, console); + round = false; } else if (!blackJack.playerSplitHand.isEmpty()) { System.out.println("Already split! Cannot split again!"); } else System.out.println("Not a pair, cannot split. Please select a valid action"); @@ -164,12 +187,101 @@ public void resetHandAndValues(BlackJack blackJack) { } public void currentTurnIndicator(BlackJack blackJack) { - if(blackJack.currentHand == blackJack.playerHand || blackJack.currentHand == blackJack.playerSplitHand) { + if(blackJack.currentHand == blackJack.playerHand) { System.out.println(String.format("Turn to act : *** %s ***", blackJack.currentPlayer.getPlayerName())); - } else if(blackJack.currentHand == blackJack.dealerHand) { + } else if(blackJack.currentHand == blackJack.playerSplitHand) { + System.out.println(String.format("Turn to act : *** %s Split Hand***", blackJack.currentPlayer.getPlayerName())); + }else if(blackJack.currentHand == blackJack.dealerHand) { System.out.println("Turn to act : *** Dealer ***"); } } + public void splitHandStart(BlackJack blackJack, Player player, Console console) { + blackJack.playerHandSplit(); + + boolean round = true; + while(round) { + currentHands(blackJack); + currentChipCount(player); + currentTurnIndicator(blackJack); + if(blackJack.playerHaveBlackJack()) { + System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); + blackJack.playerWinByBlackJack(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + break; + } + if(blackJack.playerSplitHandHaveBlackJack()) { + System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); + blackJack.playerWinByBlackJack(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + break; + } + Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t2 - Hold"); + switch (decision) { + case 1: + blackJack.hitMe(); + if(blackJack.playerBust()) { + currentHands(blackJack); + System.out.println("BUST! Next hand."); + blackJack.splitHold(); + } + if(blackJack.playerSplitHandBust()) { + currentHands(blackJack); + System.out.println("BUST! Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + if(blackJack.dealerBust()) { + currentHands(blackJack); + System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); + blackJack.playerWinPot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + break; + case 2: + if(blackJack.currentHand == blackJack.playerHand) { + blackJack.splitHold(); + break; + } + if(blackJack.currentHand == blackJack.playerSplitHand) { + blackJack.hold(); + break; + } + blackJack.hold(); + if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { + if(blackJack.checkWinner().equals("Player") || blackJack.checkSplitWinner().equals("Player")) { + System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); + blackJack.playerWinPot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } else if (blackJack.checkWinner().equals("Dealer") && blackJack.checkSplitWinner().equals("Dealer")) { + System.out.println("Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } else if (blackJack.checkWinner().equals("Tie") || blackJack.checkSplitWinner().equals("Tie")) { + System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); + blackJack.tiedPot(); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + } + break; + default: + System.out.println("Not a valid input"); + break; + } + } + } + } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 4104ac9a2..986e95406 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -446,6 +446,11 @@ public void checkSplitWinnerTieTest() { @Test public void playerHaveBlackJackTrueTest() { //Given: + Card AceOfSpades=new Card("A", "Spades", 11); + Card TenOfSpades=new Card("10", "Spades", 10); + Card EightOfSpades=new Card("8", "Spades", 8); + bj.playerHand.add(AceOfSpades); + bj.playerHand.add(TenOfSpades); bj.playerTotal = 21; bj.dealerTotal = 20; @@ -460,7 +465,12 @@ public void playerHaveBlackJackTrueTest() { @Test public void playerHaveBlackJackFalseTest() { //Given: - bj.playerTotal = 18; + Card AceOfSpades=new Card("A", "Spades", 11); + Card TenOfSpades=new Card("10", "Spades", 10); + Card EightOfSpades=new Card("8", "Spades", 8); + bj.playerHand.add(EightOfSpades); + bj.playerHand.add(TenOfSpades); + bj.playerTotal = 21; bj.dealerTotal = 20; //When: @@ -474,6 +484,11 @@ public void playerHaveBlackJackFalseTest() { @Test public void playerSplitHandHaveBlackJackTrueTest() { //Given: + Card AceOfSpades=new Card("A", "Spades", 11); + Card TenOfSpades=new Card("10", "Spades", 10); + Card EightOfSpades=new Card("8", "Spades", 8); + bj.playerSplitHand.add(TenOfSpades); + bj.playerSplitHand.add(AceOfSpades); bj.playerSplitTotal = 21; bj.dealerTotal = 18; @@ -488,6 +503,11 @@ public void playerSplitHandHaveBlackJackTrueTest() { @Test public void playerSplitHandHaveBlackJackFalseTest() { //Given: + Card AceOfSpades=new Card("A", "Spades", 11); + Card TenOfSpades=new Card("10", "Spades", 10); + Card EightOfSpades=new Card("8", "Spades", 8); + bj.playerSplitHand.add(EightOfSpades); + bj.playerSplitHand.add(TenOfSpades); bj.playerSplitTotal = 16; bj.dealerTotal = 18; @@ -502,6 +522,10 @@ public void playerSplitHandHaveBlackJackFalseTest() { @Test public void dealerHaveBlackJackTrueTest() { //Given: + Card AceOfSpades=new Card("A", "Spades", 11); + Card TenOfSpades=new Card("10", "Spades", 10); + bj.dealerHand.add(AceOfSpades); + bj.dealerHand.add(TenOfSpades); bj.playerTotal = 20; bj.dealerTotal = 21; From 5cc42a8d3f20d0a89e3b91ff08430e47e0ce82e1 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Wed, 17 Mar 2021 13:28:47 -0400 Subject: [PATCH 41/73] added a check for negative bet amounts --- .../java/io/zipcoder/casino/BlackJackEngine.java | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 7742d3f34..733a77aa0 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -45,14 +45,12 @@ public void mainBlackJackMenu(BlackJack bj, Player player, Console console) { case 1: currentChipCount(player); Integer bet = console.getIntegerInput("What is your bet?"); - boolean invalidBet = bet > player.getChipBalance(); - if(invalidBet) { - System.out.println("Balance not enough, please lower your bet or enter 0 to cancel"); - break; - } else if (bet == 0) { - mainBlackJackMenu(bj, player, console); - validInput = false; - break; + if(bet > player.getChipBalance()) { + System.out.println("Balance not enough, please lower your bet"); + continue; + } else if (bet < 0) { + System.out.println("Please enter a positive amount"); + continue; } bj.addToPot(bet); bj.playGame(); From 497749379db8fce5ba55ccfaa5329110f29f14be Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 13:43:58 -0400 Subject: [PATCH 42/73] CrapsEngine works with the placeholders for now --- src/main/java/io/zipcoder/casino/Craps.java | 5 +++ .../java/io/zipcoder/casino/CrapsEngine.java | 37 ++++++++++++++++--- .../java/io/zipcoder/casino/CrapsScreens.java | 11 ++++++ 3 files changed, 48 insertions(+), 5 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java index 19d655cd4..aa2ef16e9 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -16,6 +16,7 @@ public Craps(Player currentPlayer) { public void addToPot(int numOfChips) { pot += numOfChips; + currentPlayer.wageMoney(numOfChips); } public int getPot() { @@ -124,4 +125,8 @@ public String getBetStatus() { public int getCurrentSum() { return currentSum; } + + public void playerWinsPot(int chipsInPot) { + currentPlayer.winChips(chipsInPot * 2); + } } diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index 033317db1..1df00d28e 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -64,11 +64,25 @@ private void betAmountRoundOneScreen() { cScreens.betAmountRoundOneScreen(craps.getGameRound()); while (true) { Integer input = console.getIntegerInput(""); - if (input < player.getChipBalance() && input >= 0) { + if (input <= player.getChipBalance() && input >= 0) { craps.addToPot(input); rollTheDice(); } else { - System.out.println("Insufficient Chips"); + getMoreChips(); + } + } + } + + private void getMoreChips() { + cScreens.getMoreChips(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 0) { + casinoLobby(); + } else if (input == 1) { + betAmountRoundOneScreen(); + } else { + System.out.println("Invalid Entry"); } } } @@ -112,6 +126,18 @@ private void loseRollScreen() { craps.setGameRound(1); passOrNotPassRoundOneScreen(craps.getGameRound()); } else if (input.equals(2)) { + goodLuckScreen(); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void goodLuckScreen() { + cScreens.leaveCrapsScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 0) { casinoLobby(); } else { System.out.println("Invalid Entry"); @@ -121,13 +147,14 @@ private void loseRollScreen() { private void winRollScreen() { cScreens.winRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); + craps.playerWinsPot(craps.getPot()); while (true) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setGameRound(1); passOrNotPassRoundOneScreen(craps.getGameRound()); } else if (input.equals(2)) { - casinoLobby(); + goodLuckScreen(); } else { System.out.println("Invalid Entry"); } @@ -154,7 +181,7 @@ private void rollAgainBetScreen() { cScreens.rollAgainBetScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); while (true) { Integer input = console.getIntegerInput(""); - if (input < player.getChipBalance() && input >=0) { + if (input <= player.getChipBalance() && input >=0) { craps.addToPot(input); rollTheDiceOnward(); } else { @@ -165,7 +192,7 @@ private void rollAgainBetScreen() { private void rollTheDiceOnward() { craps.setGameRound(2); - cScreens.rollAgainOnward(craps.getGameRound(),craps.getBetStatus(), craps.getPot(), craps.getCurrentSum()); + cScreens.rollAgainOnward(craps.getGameRound(),craps.getBetStatus(), craps.getPot(), craps.getPointer()); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { diff --git a/src/main/java/io/zipcoder/casino/CrapsScreens.java b/src/main/java/io/zipcoder/casino/CrapsScreens.java index 45ca4e2df..8da466b93 100644 --- a/src/main/java/io/zipcoder/casino/CrapsScreens.java +++ b/src/main/java/io/zipcoder/casino/CrapsScreens.java @@ -204,6 +204,17 @@ public void leaveCrapsScreen() { println(" "); println(" Good Luck! "); println(" "); + println(" 0: Return to lobby "); + } + + public void getMoreChips() { + println(" "); + println(" Insufficient Chips "); + println(" "); + println(" Please go get more "); + println(" "); + println(" 0: Return to lobby "); + println(" 1: Enter different bet "); } } From 569e375bbcb246a780d39f5b5d56f68c22704748 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 14:29:31 -0400 Subject: [PATCH 43/73] Working my way through MOAK engine --- .../java/io/zipcoder/casino/CrapsEngine.java | 2 - .../io/zipcoder/casino/MostOfAKindEngine.java | 72 +++++++++++++++++++ .../io/zipcoder/casino/MostOfAKindGame.java | 11 ++- .../zipcoder/casino/MostOfAKindScreens.java | 12 +++- .../io/zipcoder/casino/MostOfAKindTests.java | 19 +---- 5 files changed, 93 insertions(+), 23 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/MostOfAKindEngine.java diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index 1df00d28e..6ed658ab1 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -5,8 +5,6 @@ public class CrapsEngine { Console console = new Console(System.in, System.out); - //boolean gameOn = true; - //PlayerWarehouse pWare = new PlayerWarehouse(); CrapsScreens cScreens = new CrapsScreens(); Player player = new Player("gerg", 500); Craps craps = new Craps(player); diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java new file mode 100644 index 000000000..9efd8f8c7 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -0,0 +1,72 @@ +package io.zipcoder.casino; + +import io.zipcoder.casino.utilities.Console; + +import java.util.ArrayList; + +public class MostOfAKindEngine { + Console console = new Console(System.in, System.out); + MostOfAKindScreens mScreens = new MostOfAKindScreens(); + Player player = new Player("gerg", 500); + MostOfAKindGame moak = new MostOfAKindGame(player); + + public static void main(String[] args) { + MostOfAKindEngine moak = new MostOfAKindEngine(); + moak.startMoakGame(); + } + + private void startMoakGame() { + mScreens.welcomeMoakScreen(); + player.setChipBalance(100); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + anteUpScreen(); + } else if (input == 2) { + casinoLobby(); + } else { + welcomeInvalidScreen(); + } + } + } + + //PLACEHOLDER + private void casinoLobby() { + System.exit(0); + } + + private void welcomeInvalidScreen() { + mScreens.welcomeInvalidMoakScreen(); + } + + private void anteUpScreen() { + mScreens.anteUpScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + moak.anteUp(); + moak.makePlayerHand(5); + firstRollScreen(moak.getPot(), moak.getPlayerHand()); + } else if (player.getChipBalance() <= 2) { + needMoreChipsScreen(); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void needMoreChipsScreen() { + mScreens.needMoreChipsScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 0) { + casinoLobby(); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void firstRollScreen(int pot, ArrayList playerHand) { + } +} diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 846b72182..cde93b842 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -12,6 +12,11 @@ public class MostOfAKindGame extends DiceGame { int dealerMatchingNum; int dealerCount; int playerCount; + Player currentPlayer; + + public MostOfAKindGame(Player player) { + this.currentPlayer = player; + } public void addToPot(int numOfChips) { pot += numOfChips; @@ -69,7 +74,7 @@ public ArrayList getDealerHand() { } public ArrayList getPlayerHand() { - return this.playerDiceHand; + return playerDiceHand; } public void exchangePlayerDice(int numToKeep) { @@ -134,4 +139,8 @@ public void dealerNumOfMatches(ArrayList dealerSecondHand) { } } } + + public void anteUp() { + currentPlayer.bet(2); + } } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java b/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java index 059738220..52e43054a 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java @@ -10,7 +10,7 @@ public void welcomeMoakScreen() { println(" ------------------------- "); println(" Would you like to play? "); println(" "); - println(" Y or N "); + println(" 1: Yes 2: No "); println(" "); } @@ -20,7 +20,7 @@ public void welcomeInvalidMoakScreen() { println(" ------------------------- "); println(" Would you like to play? "); println(" "); - println(" Y or N "); + println(" 1: Yes 2: No "); println(" "); } @@ -112,5 +112,11 @@ public void goodbyeScreen() { } - + public void needMoreChipsScreen() { + println(" "); + println(" You need more chips "); + println(" "); + println(" 0: Go back to lobby "); + println(" "); + } } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 89b661f1a..fc0227b29 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -7,11 +7,12 @@ import java.util.ArrayList; public class MostOfAKindTests { + Player gerg = PlayerFactory.createPlayer("gerg", 500); + MostOfAKindGame yahtzee = new MostOfAKindGame(gerg); @Test public void getPot() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); int expected = 0; //When @@ -24,7 +25,6 @@ public void getPot() { @Test public void addToPot() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); int expected = 5; //When @@ -38,7 +38,6 @@ public void addToPot() { @Test public void clearPot() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); int expected = 0; yahtzee.addToPot(7); yahtzee.clearPot(); @@ -53,7 +52,6 @@ public void clearPot() { @Test public void rollDice() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); //When int result = yahtzee.rollDice(); @@ -65,7 +63,6 @@ public void rollDice() { @Test public void addToPlayerCount() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.addToPlayerCount(3); int expected = 3; @@ -79,7 +76,6 @@ public void addToPlayerCount() { @Test public void checkWinnerDealer() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.addToPlayerCount(3); yahtzee.addToDealerCount(4); @@ -93,7 +89,6 @@ public void checkWinnerDealer() { @Test public void checkWinnerPlayer() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.addToPlayerCount(4); yahtzee.addToDealerCount(2); @@ -107,7 +102,6 @@ public void checkWinnerPlayer() { @Test public void makeDealerHand() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); //When yahtzee.makeDealerHand(5); @@ -120,7 +114,6 @@ public void makeDealerHand() { @Test public void makePlayerHand() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); //When yahtzee.makePlayerHand(5); @@ -133,7 +126,6 @@ public void makePlayerHand() { @Test public void playerSecondRoll() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.playerDiceHand.add(5); yahtzee.playerDiceHand.add(4); yahtzee.playerDiceHand.add(3); @@ -151,7 +143,6 @@ public void playerSecondRoll() { @Test public void dealerSecondRoll() { - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.dealerHand.add(2); yahtzee.dealerHand.add(2); yahtzee.dealerHand.add(1); @@ -170,7 +161,6 @@ public void dealerSecondRoll() { @Test public void playerSecondRollIrrational() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.playerDiceHand.add(5); yahtzee.playerDiceHand.add(4); yahtzee.playerDiceHand.add(3); @@ -189,7 +179,6 @@ public void playerSecondRollIrrational() { @Test public void dealerSecondRollIrrational() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.dealerHand.add(2); yahtzee.dealerHand.add(2); yahtzee.dealerHand.add(1); @@ -208,7 +197,6 @@ public void dealerSecondRollIrrational() { @Test public void setGetPlayerMatchingNum() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.setPlayerMatchingNum(5); int expected = 5; @@ -222,7 +210,6 @@ public void setGetPlayerMatchingNum() { @Test public void setGetDealerMatchingNum() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.setDealerMatchingNum(2); int expected = 2; @@ -236,7 +223,6 @@ public void setGetDealerMatchingNum() { @Test public void getPlayerNumOfMatches() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.playerDiceHand.add(5); yahtzee.playerDiceHand.add(5); yahtzee.playerDiceHand.add(5); @@ -255,7 +241,6 @@ public void getPlayerNumOfMatches() { @Test public void getDealerNumOfMatches() { //Given - MostOfAKindGame yahtzee = new MostOfAKindGame(); yahtzee.dealerHand.add(2); yahtzee.dealerHand.add(2); yahtzee.dealerHand.add(2); From 264ae73f8b83bd0a524e31d0b2320e136cca70db Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 16:17:43 -0400 Subject: [PATCH 44/73] working version of MOAK. Need to implement Dealer AI --- .../java/io/zipcoder/casino/DiceGame.java | 3 +- .../io/zipcoder/casino/MostOfAKindEngine.java | 113 +++++++++++++++++- .../io/zipcoder/casino/MostOfAKindGame.java | 23 +++- .../zipcoder/casino/MostOfAKindScreens.java | 22 ++++ 4 files changed, 150 insertions(+), 11 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/DiceGame.java b/src/main/java/io/zipcoder/casino/DiceGame.java index 5e34aca46..ba20cff70 100644 --- a/src/main/java/io/zipcoder/casino/DiceGame.java +++ b/src/main/java/io/zipcoder/casino/DiceGame.java @@ -7,7 +7,8 @@ public abstract class DiceGame implements GamblingGame { ArrayList playerDiceHand = new ArrayList(); int pot = 0; - public void addToPot() {} + public void addToPot() { + } public void clearPot() { pot = 0; diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index 9efd8f8c7..6f7dd911a 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -39,16 +39,21 @@ private void welcomeInvalidScreen() { mScreens.welcomeInvalidMoakScreen(); } + //Takes 5 chips, makes dealer and player hands private void anteUpScreen() { + moak.clearPot(); mScreens.anteUpScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - moak.anteUp(); - moak.makePlayerHand(5); - firstRollScreen(moak.getPot(), moak.getPlayerHand()); - } else if (player.getChipBalance() <= 2) { - needMoreChipsScreen(); + if (player.getChipBalance() < 10) { + needMoreChipsScreen(); + } else { + moak.anteUp(); + moak.makePlayerHand(5); + moak.makeDealerHand(5); + firstRollScreen(moak.getPot(), moak.getPlayerHand()); + } } else { System.out.println("Invalid Entry"); } @@ -68,5 +73,103 @@ private void needMoreChipsScreen() { } private void firstRollScreen(int pot, ArrayList playerHand) { + mScreens.firstRollScreen(pot, playerHand); + while (true) { + Integer input = console.getIntegerInput(""); + if (input <= player.getChipBalance() && input >= 0) { + moak.addToPot(input); + numberToKeepScreen(moak.getPot(), moak.getPlayerHand()); + } else { + getMoreChips(); + } + } + } + + private void getMoreChips() { + mScreens.getMoreChips(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 0) { + casinoLobby(); + } else if (input == 1) { + firstRollScreen(moak.getPot(), moak.getPlayerHand()); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void numberToKeepScreen(int pot, ArrayList playerHand) { + mScreens.numberToKeepScreen(pot, playerHand); + while (true) { + Integer input = console.getIntegerInput(""); + if (moak.getPlayerHand().contains(input)) { + moak.exchangePlayerDice(input); + secondRollScreen(moak.getPot(), moak.getPlayerHand()); + } else if (input == 0) { + moak.clearPlayerHand(); + moak.makePlayerHand(5); + secondRollScreen(moak.getPot(), moak.getPlayerHand()); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void secondRollScreen(int pot, ArrayList playerHand) { + mScreens.secondRollScreen(pot, playerHand); + while (true) { + Integer input = console.getIntegerInput(""); + if (input <= player.getChipBalance() && input >= 0) { + moak.addToPot(input); + moak.playerNumOfMatches(playerHand); + if (moak.checkWinner() == true) { + revealHandsPlayerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand()); + } else { + //catches when dealer wins + revealHandsDealerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand()); + } + } + } + } + + private void revealHandsDealerWins(int pot, ArrayList playerHand, ArrayList dealerHand) { + mScreens.revealHandsDealerWins(pot, playerHand, dealerHand); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + anteUpScreen(); + } else if (input == 2) { + goodbyeScreen(); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void revealHandsPlayerWins(int pot, ArrayList playerHand, ArrayList dealerHand) { + mScreens.revealHandsPlayerWins(pot, playerHand, dealerHand); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + anteUpScreen(); + } else if (input == 2) { + goodbyeScreen(); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void goodbyeScreen() { + mScreens.goodbyeScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 0) { + casinoLobby(); + } else { + System.out.println("Invalid Entry"); + } + } } } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index cde93b842..823b66d7a 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -18,10 +18,6 @@ public MostOfAKindGame(Player player) { this.currentPlayer = player; } - public void addToPot(int numOfChips) { - pot += numOfChips; - } - public int getPot() { return pot; } @@ -40,6 +36,13 @@ public boolean checkWinner() { doIWin = true; } else if (getDealerCount() > getPlayerCount()) { doIWin = false; + } else if (getDealerCount() == getPlayerCount()) { + if (playerMatchingNum > dealerMatchingNum) { + doIWin = true; + } else { + //catches when dealerMatchingNum bigger + doIWin = false; + } } return doIWin; } @@ -141,6 +144,16 @@ public void dealerNumOfMatches(ArrayList dealerSecondHand) { } public void anteUp() { - currentPlayer.bet(2); + currentPlayer.bet(5); + pot += 5; + } + + public void addToPot(int numOfChips) { + pot += numOfChips; + currentPlayer.wageMoney(numOfChips); + } + + public void clearPlayerHand() { + playerDiceHand.clear(); } } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java b/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java index 52e43054a..46969826e 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java @@ -53,6 +53,8 @@ public void numberToKeepScreen(int pot, ArrayList playerDice) { println(" "); println("Which number do you want to keep?"); println(" "); + println(" 0: Roll all dice again "); + println(" "); } //SECOND ROLL @@ -79,6 +81,11 @@ public void revealHandsPlayerWins(int pot, ArrayList playerDice, ArrayL println("%s ", dealerDice); println(" "); println(" YOU WIN! "); + println(" "); + println(" Do you want to play again? "); + println(" "); + println(" 1: Yes 2: No "); + println(" "); } public void revealHandsDealerWins(int pot, ArrayList playerDice, ArrayList dealerDice) { @@ -93,6 +100,10 @@ public void revealHandsDealerWins(int pot, ArrayList playerDice, ArrayL println(" "); println(" House wins "); println(" "); + println(" Do you want to play again? "); + println(" "); + println(" 1: Yes 2: No "); + println(" "); } @@ -109,6 +120,8 @@ public void goodbyeScreen() { println(" "); println(" Good Luck! "); println(" "); + println(" 0: Return to lobby "); + println(" "); } @@ -119,4 +132,13 @@ public void needMoreChipsScreen() { println(" 0: Go back to lobby "); println(" "); } + + public void getMoreChips() { + println(" "); + println(" Insufficient Chips "); + println(" "); + println(" 0: Go back to lobby "); + println(" 1: Enter different bet "); + println(" "); + } } From bf2638e70331d15a7f8018f6638aef97333d35ac Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Wed, 17 Mar 2021 16:29:43 -0400 Subject: [PATCH 45/73] WOOOOO playable gofish build --- .../java/io/zipcoder/casino/CardGame.java | 4 + src/main/java/io/zipcoder/casino/GoFish.java | 129 +++++++++++++----- .../java/io/zipcoder/casino/GoFishEngine.java | 9 ++ .../java/io/zipcoder/casino/GoFishTest.java | 3 +- 4 files changed, 106 insertions(+), 39 deletions(-) create mode 100644 src/main/java/io/zipcoder/casino/GoFishEngine.java diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java index 67c1b7c32..dddfde905 100644 --- a/src/main/java/io/zipcoder/casino/CardGame.java +++ b/src/main/java/io/zipcoder/casino/CardGame.java @@ -165,4 +165,8 @@ public void clearDiscardAndDeck(){ discardPile.clear(); } + public Integer getCardsLeftInDeck(){ + return deck.size(); + } + } diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index 86ba4b1b1..a3f9ab1cd 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Random; public class GoFish extends CardGame { private List oswald= new ArrayList<>(); @@ -14,48 +15,23 @@ public class GoFish extends CardGame { public GoFish(Player current){ currentplayer=current; - makeDeck(); - shuffleDeck(); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); } //blank constructor, mostly to make tests easier. public GoFish(){ - makeDeck(); - shuffleDeck(); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); - dealCards(oswald); - dealCards(dealer); + } public void playGame() { System.out.println("Welcome to Go Fish, "+currentplayer.getPlayerName()); System.out.println("This is a nice, friendly game so don't worry about " + "the chips, okay?"); + System.out.println("Are you ready to begin? (enter 'yes' or 'y')"); + String input = Displays.getStringInput(); + Boolean stillPlaying; + //The actual GAME starts here. + while(input.equalsIgnoreCase("yes")||input.equalsIgnoreCase("y")){ + newGameState(); for(int i=0; i<7;i++){ if (completeSet(oswald, oswald.get(0).getCardName())){ playerScore++; @@ -66,7 +42,26 @@ public void playGame() { } if(playerScore>0||dealerScore>0){ System.out.println("We already have some books! Crazy!");} - + stillPlaying=true; + while(stillPlaying==true) { + //player takes their turn + if(stillPlaying==true){ + System.out.println("You have "+playerScore+" books."); + turnStructure();} + //end step for player, checks for winner + if(getCardsLeftInDeck()==0||books.size()==12){ + stillPlaying=false;} + if(stillPlaying==true){turnStructureAI(); + System.out.println("The dealer has "+dealerScore+" books.");} + //end step for dealer, checks for winner + if(getCardsLeftInDeck()==0||books.size()==12){ + stillPlaying=false;} + } + System.out.println(checkWinner()); + System.out.println("Did you want to play again? (enter 'yes' or 'y')"); + input = Displays.getStringInput(); + } + System.out.println("Okay then, take care and thanks for playing!"); } public String checkWinner() { @@ -74,6 +69,29 @@ public String checkWinner() { else return "You win! Congrats!"; } + public void newGameState(){ + clearDiscardAndDeck(); + oswald.clear(); + dealer.clear(); + dealerScore=0; + playerScore=0; + makeDeck(); + shuffleDeck(); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + dealCards(oswald); + dealCards(dealer); + } @@ -82,6 +100,7 @@ public void turnStructure(){ Boolean takeAnotherTurn=true; String input=""; while (takeAnotherTurn) { + System.out.print(seeHand(oswald)); System.out.println("Alright, Go fish!"); takeAnotherTurn=false; legalchoice=false; @@ -95,10 +114,9 @@ public void turnStructure(){ } } if (gotAnyKings(dealer, input)) { - System.out.println("You caught fish!"); takeCards(oswald, dealer, input); takeAnotherTurn=true; - System.out.println("You caught a fish! You get another turn!"); + System.out.println("You caught a "+showCard(oswald, oswald.size()-1)+"! You get another turn!"); if(completeSet(oswald, input)){ playerScore++; System.out.println("Congrats, you closed a book!"); @@ -106,6 +124,7 @@ public void turnStructure(){ } else { System.out.println("Whoops! No bites, better draw!"); dealCards(oswald); + System.out.println("You drew: "+showCard(oswald, oswald.size()-1)); if(completeSet(oswald, oswald.get(oswald.size()-1).getCardName())){ playerScore++; System.out.println("Congrats, you closed a book!"); @@ -119,6 +138,41 @@ public void turnStructure(){ System.out.println("Turn over!"); } + public void turnStructureAI(){ + Boolean takeAnotherTurn=true; + String input=""; + while (takeAnotherTurn) { + System.out.println("Okay, now it's the dealer's turn!"); + takeAnotherTurn=false; + Random r=new Random(); + Integer rand=r.nextInt(dealer.size()); + input=dealer.get(rand).getCardName(); + System.out.println("Dealer asks: 'got any "+input+"'s?"); + + if (gotAnyKings(oswald, input)) { + takeCards(dealer,oswald,input); + System.out.println("Dealer caught a"+showCard(dealer, dealer.size()-1)+"! They get another turn!"); + takeAnotherTurn=true; + if(completeSet(dealer, input)){ + dealerScore++; + System.out.println("Dealer closes a book!"); + } + } else { + System.out.println("Dealer draws!"); + dealCards(dealer); + if(completeSet(dealer, dealer.get(dealer.size()-1).getCardName())){ + dealerScore++; + System.out.println("Dealer closes a book!"); + } + if(drawAnyKings(dealer,input)){ + takeAnotherTurn=true; + System.out.println("Dealer drew a fish! They get another turn!"); + } + } + } + System.out.println("Dealer's turn over!"); + } + public Integer cardsInHand(List player){ return player.size(); } @@ -139,7 +193,7 @@ public String seeHand(List player){ public Boolean gotAnyKings(List hand, String name) { for(Card i:hand){ - if(name.equals(i.getCardName())){ + if(name.equalsIgnoreCase(i.getCardName())){ return true; } } @@ -151,12 +205,13 @@ public void takeCards(List taker, List taken, String name) { if(name.equals(taken.get(i).getCardName())){ taker.add(taken.get(i)); taken.remove(i); + i=0; } } } public Boolean drawAnyKings(List player, String name) { - if(name.equals(player.get(player.size()-1).getCardName())){ + if(name.equalsIgnoreCase(player.get(player.size()-1).getCardName())){ return true; } return false; diff --git a/src/main/java/io/zipcoder/casino/GoFishEngine.java b/src/main/java/io/zipcoder/casino/GoFishEngine.java new file mode 100644 index 000000000..9f64de003 --- /dev/null +++ b/src/main/java/io/zipcoder/casino/GoFishEngine.java @@ -0,0 +1,9 @@ +package io.zipcoder.casino; + +public class GoFishEngine { + public static void main(String[] args) { + Player dummy=new Player("Arg",1000); + GoFish demo=new GoFish(dummy); + demo.playGame(); + } +} diff --git a/src/main/java/io/zipcoder/casino/GoFishTest.java b/src/main/java/io/zipcoder/casino/GoFishTest.java index d98e6e5fa..22320a20e 100644 --- a/src/main/java/io/zipcoder/casino/GoFishTest.java +++ b/src/main/java/io/zipcoder/casino/GoFishTest.java @@ -184,7 +184,7 @@ public void testDrawAnyKings3(){ } @Test - public void testDrawAnyKings4(){ + public void testBookClose(){ GoFish friendlyGame=new GoFish(); ArrayList oswald= new ArrayList<>(); friendlyGame.makeDeck(); @@ -256,5 +256,4 @@ public void testDrawAnyKings4(){ Assert.assertTrue(friendlyGame.completeSet(oswald, "K")); } - } From 4a3985402c160a97f17bf2e4fc16d9e425f4380e Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 16:47:24 -0400 Subject: [PATCH 46/73] ALMOST fully functioning MOAK. Dealer count to determine winner messes up when playercount is equal to dealercount --- .../io/zipcoder/casino/MostOfAKindEngine.java | 5 +++ .../io/zipcoder/casino/MostOfAKindGame.java | 34 ++++++++++++++++++- .../io/zipcoder/casino/MostOfAKindTests.java | 21 ++++++++++++ 3 files changed, 59 insertions(+), 1 deletion(-) diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index 6f7dd911a..a4b6eeb1d 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -42,6 +42,8 @@ private void welcomeInvalidScreen() { //Takes 5 chips, makes dealer and player hands private void anteUpScreen() { moak.clearPot(); + moak.clearPlayerHand(); + moak.clearDealerHand(); mScreens.anteUpScreen(); while (true) { Integer input = console.getIntegerInput(""); @@ -105,10 +107,13 @@ private void numberToKeepScreen(int pot, ArrayList playerHand) { Integer input = console.getIntegerInput(""); if (moak.getPlayerHand().contains(input)) { moak.exchangePlayerDice(input); + moak.dealerAINumbersToKeep(moak.getDealerHand()); + moak.exchangeDealerDice(moak.dealerMatchingNum); secondRollScreen(moak.getPot(), moak.getPlayerHand()); } else if (input == 0) { moak.clearPlayerHand(); moak.makePlayerHand(5); + moak.dealerAINumbersToKeep(moak.getDealerHand()); secondRollScreen(moak.getPot(), moak.getPlayerHand()); } else { System.out.println("Invalid Entry"); diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 823b66d7a..4672bcdc3 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -39,7 +39,7 @@ public boolean checkWinner() { } else if (getDealerCount() == getPlayerCount()) { if (playerMatchingNum > dealerMatchingNum) { doIWin = true; - } else { + } else if (dealerMatchingNum > playerMatchingNum) { //catches when dealerMatchingNum bigger doIWin = false; } @@ -143,6 +143,34 @@ public void dealerNumOfMatches(ArrayList dealerSecondHand) { } } + public void dealerAINumbersToKeep(ArrayList dealerHand) { + int matchOne; + int counterOne = 1; + int matchTwo = 0; + int counterTwo = 1; + + for (int i = 0; i < dealerHand.size()-1; i++) { + matchOne = dealerHand.get(i); + for (int j = i+1; j < dealerHand.size(); j++) { + if (dealerHand.get(j) == dealerHand.get(i)) { + counterOne++; + } + } + if (counterOne > counterTwo) { + matchTwo = matchOne; + counterTwo = counterOne; + } else if (counterOne == counterTwo) { + if (matchOne > matchTwo) { + matchTwo = matchOne; + counterTwo = counterOne; + } + } + counterOne = 1; + } + dealerMatchingNum = matchTwo; + dealerCount = counterTwo; + } + public void anteUp() { currentPlayer.bet(5); pot += 5; @@ -156,4 +184,8 @@ public void addToPot(int numOfChips) { public void clearPlayerHand() { playerDiceHand.clear(); } + + public void clearDealerHand() { + dealerHand.clear(); + } } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index fc0227b29..79b98321e 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -256,4 +256,25 @@ public void getDealerNumOfMatches() { Assert.assertEquals(expected, actual); } + @Test + public void dealerAI() { + //Given + ArrayList dealerHand = new ArrayList<>(); + dealerHand.add(5); + dealerHand.add(2); + dealerHand.add(5); + dealerHand.add(1); + dealerHand.add(5); + + //When + yahtzee.dealerAINumbersToKeep(dealerHand); + int expectedCount = 3; + int expectedMatch = 5; + int actualCount = yahtzee.getDealerCount(); + int actualMatch = yahtzee.getDealerMatchingNum(); + + //Then + Assert.assertEquals(expectedCount, actualCount); + Assert.assertEquals(expectedMatch, actualMatch); + } } From 1c2abbef5a482efc8fd0915fa46f1b43a3cdc1ce Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 17:08:51 -0400 Subject: [PATCH 47/73] MostOfAKind works!!!! --- .../io/zipcoder/casino/MostOfAKindEngine.java | 1 + .../io/zipcoder/casino/MostOfAKindGame.java | 6 +++ .../io/zipcoder/casino/MostOfAKindTests.java | 50 +++++++++++++++++++ 3 files changed, 57 insertions(+) diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index a4b6eeb1d..8b1594ca8 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -154,6 +154,7 @@ private void revealHandsDealerWins(int pot, ArrayList playerHand, Array private void revealHandsPlayerWins(int pot, ArrayList playerHand, ArrayList dealerHand) { mScreens.revealHandsPlayerWins(pot, playerHand, dealerHand); + moak.playerWinsPot(moak.getPot()); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 4672bcdc3..1360b891f 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -81,6 +81,7 @@ public ArrayList getPlayerHand() { } public void exchangePlayerDice(int numToKeep) { + playerMatchingNum = numToKeep; ArrayList newHand = new ArrayList(); int numOfDiceKeeping = 0; for (int i = 0; i < getPlayerHand().size(); i++) { @@ -95,6 +96,7 @@ public void exchangePlayerDice(int numToKeep) { } public void exchangeDealerDice(int numToKeep) { + dealerMatchingNum = numToKeep; ArrayList newDealerHand = new ArrayList(); int numOfDiceKeeping = 0; for (int i = 0; i < getDealerHand().size(); i++) { @@ -188,4 +190,8 @@ public void clearPlayerHand() { public void clearDealerHand() { dealerHand.clear(); } + + public void playerWinsPot(int pot) { + currentPlayer.winChips(pot * 2); + } } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 79b98321e..4dc73e014 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -99,6 +99,34 @@ public void checkWinnerPlayer() { Assert.assertTrue(actual); } + @Test + public void extensiveCheckWinner() { + ArrayList dealerHand = new ArrayList<>(); + dealerHand.add(5); + dealerHand.add(5); + dealerHand.add(5); + dealerHand.add(5); + dealerHand.add(5); + + ArrayList playerHand = new ArrayList<>(); + playerHand.add(6); + playerHand.add(6); + playerHand.add(6); + playerHand.add(6); + playerHand.add(6); + + //When + yahtzee.exchangePlayerDice(6); + yahtzee.exchangeDealerDice(5); + yahtzee.playerNumOfMatches(playerHand); + yahtzee.dealerNumOfMatches(dealerHand); + + boolean expected = true; + boolean actual = yahtzee.checkWinner(); + + Assert.assertEquals(expected, actual); + } + @Test public void makeDealerHand() { //Given @@ -277,4 +305,26 @@ public void dealerAI() { Assert.assertEquals(expectedCount, actualCount); Assert.assertEquals(expectedMatch, actualMatch); } + + @Test + public void dealerAITwo() { + //Given + ArrayList dealerHand = new ArrayList<>(); + dealerHand.add(5); + dealerHand.add(5); + dealerHand.add(5); + dealerHand.add(1); + dealerHand.add(5); + + //When + yahtzee.dealerAINumbersToKeep(dealerHand); + int expectedCount = 4; + int expectedMatch = 5; + int actualCount = yahtzee.getDealerCount(); + int actualMatch = yahtzee.getDealerMatchingNum(); + + //Then + Assert.assertEquals(expectedCount, actualCount); + Assert.assertEquals(expectedMatch, actualMatch); + } } From fc3a402766013b827d999165ac29b7b794112364 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Wed, 17 Mar 2021 17:15:34 -0400 Subject: [PATCH 48/73] some edits for cleaner messages --- src/main/java/io/zipcoder/casino/GoFish.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index a3f9ab1cd..466177c70 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -116,7 +116,7 @@ public void turnStructure(){ if (gotAnyKings(dealer, input)) { takeCards(oswald, dealer, input); takeAnotherTurn=true; - System.out.println("You caught a "+showCard(oswald, oswald.size()-1)+"! You get another turn!"); + System.out.println("You caught a fish! You get another turn!"); if(completeSet(oswald, input)){ playerScore++; System.out.println("Congrats, you closed a book!"); @@ -151,15 +151,15 @@ public void turnStructureAI(){ if (gotAnyKings(oswald, input)) { takeCards(dealer,oswald,input); - System.out.println("Dealer caught a"+showCard(dealer, dealer.size()-1)+"! They get another turn!"); + System.out.println("Dealer caught a fish! They get another turn!"); takeAnotherTurn=true; if(completeSet(dealer, input)){ dealerScore++; System.out.println("Dealer closes a book!"); } } else { - System.out.println("Dealer draws!"); dealCards(dealer); + System.out.println("You didn't! Dealer draws a "+showCard(dealer, dealer.size()-1)+"!"); if(completeSet(dealer, dealer.get(dealer.size()-1).getCardName())){ dealerScore++; System.out.println("Dealer closes a book!"); From d7e42158627f94d1fb01b7ec4cbfd44ebb13fe45 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Wed, 17 Mar 2021 21:24:29 -0400 Subject: [PATCH 49/73] We need to flesh out how to call on the engines to run each game. I'm also not sure I know which fields will be needed. I just put stuff in for now to make it run. But I know it needs to change --- src/main/java/io/zipcoder/casino/Casino.java | 126 +++++++++++++++++- .../casino/DisplayMainCasinoScreens.java | 11 ++ 2 files changed, 136 insertions(+), 1 deletion(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 8620bdb34..fea19a51a 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -4,11 +4,135 @@ import io.zipcoder.casino.utilities.Console; public class Casino { - public static void main(String[] args) { + /* + Want to double check how to call the engines + Clarify which fields we need for this class + + */ + + DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); + Console console = new Console(System.in, System.out); + GoFish goFish = new GoFish(); + BlackJackEngine blackJack = new BlackJackEngine(); + CrapsEngine crapsEngine = new CrapsEngine(); + MostOfAKindEngine moak = new MostOfAKindEngine(); + ChipMoneyExchange exchange = new ChipMoneyExchange(); + Player currentPlayer = new Player("gerg", 500); + + public static void main(String[] args) { + Casino casino = new Casino(); + casino.run(); } public void run() { + casinoScreens.welcomeScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 00) { + casinoLobbyScreen(); + } else if (input == 99) { + goodbyeCasinoScreen(); + } else { + invalidEntryWelcomeScreen(); + } + } + } + + private void invalidEntryWelcomeScreen() { + casinoScreens.invalidEntryWelcomeScreen(); + } + + private void goodbyeCasinoScreen() { + casinoScreens.goodbyeCasinoScreen(); + System.exit(0); + } + + private void casinoLobbyScreen() { + casinoScreens.casinoLobbyScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + tellerWindow(); + } else if (input == 2) { + //I think this is what I need to call... + goFish.playGame(); + } else if (input == 3) { + //Double check this is right + blackJack.blackJack(); + } else if (input == 4) { + //craps + } else if (input == 5) { + //most of a kind + } else if (input == 00) { + goodbyeCasinoScreen(); + } else { + casinoLobbyInvalidScreen(); + } + } + } + + private void casinoLobbyInvalidScreen() { + casinoScreens.casinoLobbyInvalidScreen(); + } + + private void tellerWindow() { + casinoScreens.tellerMainScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + tellerMoneyToChipsScreen(); + } else if (input == 2) { + cashOutChips(currentPlayer.getChipBalance()); + currentPlayer.setChipBalance(0); + } else { + tellerInvalidMainScreen(); + } + } + } + + private void tellerInvalidMainScreen() { + casinoScreens.tellerInvalidMainScreen(); + } + + private void cashOutChips(int chipsCashOut) { + casinoScreens.tellerChipsToMoneyScreen(chipsCashOut); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + tellerWindow(); + } else if (input == 2) { + System.exit(0); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void tellerMoneyToChipsScreen() { + casinoScreens.tellerMoneyToChipsScreen(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input <= currentPlayer.getWallet()) { + int chips = exchange.moneyToChips(input); + currentPlayer.setChipBalance(chips); + chipBalanceScreen(currentPlayer.getChipBalance()); + } else { + System.out.println("Invalid Entry"); + } + } + } + + private void chipBalanceScreen(int chips) { + casinoScreens.howManyChipsScreen(chips); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 00) { + casinoLobbyScreen(); + } else { + System.out.println("Invalid Entry"); + } + } } } diff --git a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java index 50badccca..c994b67ba 100644 --- a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java +++ b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java @@ -56,6 +56,7 @@ public void casinoLobbyScreen() { println(" 3: BlackJack Room "); println(" 4: Craps Room "); println(" 5: Poker Dice Room "); + println(" 00: Leave "); println(" "); println(" *Don't need chips to play "); println(" "); @@ -71,6 +72,7 @@ public void casinoLobbyInvalidScreen() { println(" 3: BlackJack Room "); println(" 4: Craps Room "); println(" 5: Poker Dice Room "); + println(" 00: Leave "); println(" "); println(" *Don't need chips to play "); println(" "); @@ -114,4 +116,13 @@ public void tellerChipsToMoneyScreen(int numOfPlayerChips) { println(" 1: Another transaction "); println(" 2: Exit "); } + + public void howManyChipsScreen (int cashIn) { + println(" "); + println(" Your new chip balance: "); + println(" %s ", cashIn); + println(" "); + println(" 00: Casino Lobby "); + println(" "); + } } From 1c62e6463c0953584194526695d8c03d952f1d8d Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 13:44:51 -0400 Subject: [PATCH 50/73] added AI for dealer and organized BlackJackEngine class --- .../io/zipcoder/casino/BlackJackEngine.java | 86 ++++++++----------- 1 file changed, 38 insertions(+), 48 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 733a77aa0..60a000489 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -22,17 +22,6 @@ public void blackJack() { while (gameOn) { mainBlackJackMenu(bj, player, console); -// String choice = console.getStringInput("Would you like to play again? Yes/No"); -// while(true) { -// if(choice.equalsIgnoreCase("yes")) { -// continue; -// } else if (choice.equalsIgnoreCase("no")) { -// System.out.println("Good bye!"); -// gameOn = false; -// } else choice = console.getStringInput("Please choose yes or no"); -// break; -// } - } } @@ -68,24 +57,6 @@ public void mainBlackJackMenu(BlackJack bj, Player player, Console console) { } } - - - public void currentHands(BlackJack blackJack) { - System.out.println(String.format("Dealer current hand: %s\n",blackJack.dealerTotal)); - System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.dealerHand)); - if(!blackJack.playerSplitHand.isEmpty()) { - System.out.println(String.format("\nPlayer current split hand: %s\n", blackJack.playerSplitTotal)); - System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.playerSplitHand)); - } - System.out.println(String.format("\nPlayer current hand: %s\n", blackJack.playerTotal)); - System.out.println(String.format("\t\t\t\t\t=== %s ===\n", blackJack.playerHand)); - } - - public void currentChipCount(Player player) { - System.out.println(String.format("%s : Your current chip count is %7d\n", player.getPlayerName(), player.getChipBalance())); - } - - public void roundStart(BlackJack blackJack, Player player, Console console) { System.out.println(String.format("Hello %s", player.getPlayerName())); @@ -138,6 +109,11 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { break; case 2: blackJack.hold(); + while (blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal < 16) { + blackJack.hitMe(); + System.out.println(String.format("Dealer hits and gets a %s", blackJack.dealerHand.get(blackJack.dealerHand.size() - 1))); + currentHands(blackJack); + } if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { if(blackJack.checkWinner().equals("Player")) { System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); @@ -175,25 +151,6 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { } } - public void resetHandAndValues(BlackJack blackJack) { - blackJack.discardHand(blackJack.playerHand); - blackJack.discardHand(blackJack.playerSplitHand); - blackJack.discardHand(blackJack.dealerHand); - blackJack.playerTotal = 0; - blackJack.playerSplitTotal = 0; - blackJack.dealerTotal = 0; - } - - public void currentTurnIndicator(BlackJack blackJack) { - if(blackJack.currentHand == blackJack.playerHand) { - System.out.println(String.format("Turn to act : *** %s ***", blackJack.currentPlayer.getPlayerName())); - } else if(blackJack.currentHand == blackJack.playerSplitHand) { - System.out.println(String.format("Turn to act : *** %s Split Hand***", blackJack.currentPlayer.getPlayerName())); - }else if(blackJack.currentHand == blackJack.dealerHand) { - System.out.println("Turn to act : *** Dealer ***"); - } - } - public void splitHandStart(BlackJack blackJack, Player player, Console console) { blackJack.playerHandSplit(); @@ -281,5 +238,38 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) } } + public void currentHands(BlackJack blackJack) { + System.out.println(String.format("Dealer current hand: %s\n",blackJack.dealerTotal)); + System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.dealerHand)); + if(!blackJack.playerSplitHand.isEmpty()) { + System.out.println(String.format("\nPlayer current split hand: %s\n", blackJack.playerSplitTotal)); + System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.playerSplitHand)); + } + System.out.println(String.format("\nPlayer current hand: %s\n", blackJack.playerTotal)); + System.out.println(String.format("\t\t\t\t\t=== %s ===\n", blackJack.playerHand)); + } + + public void currentChipCount(Player player) { + System.out.println(String.format("%s : Your current chip count is %7d\n", player.getPlayerName(), player.getChipBalance())); + } + + public void resetHandAndValues(BlackJack blackJack) { + blackJack.discardHand(blackJack.playerHand); + blackJack.discardHand(blackJack.playerSplitHand); + blackJack.discardHand(blackJack.dealerHand); + blackJack.playerTotal = 0; + blackJack.playerSplitTotal = 0; + blackJack.dealerTotal = 0; + } + + public void currentTurnIndicator(BlackJack blackJack) { + if(blackJack.currentHand == blackJack.playerHand) { + System.out.println(String.format("Turn to act : *** %s ***", blackJack.currentPlayer.getPlayerName())); + } else if(blackJack.currentHand == blackJack.playerSplitHand) { + System.out.println(String.format("Turn to act : *** %s Split Hand***", blackJack.currentPlayer.getPlayerName())); + }else if(blackJack.currentHand == blackJack.dealerHand) { + System.out.println("Turn to act : *** Dealer ***"); + } + } } From efc13b490048856e477fb99dfecefb39c79a51b1 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Thu, 18 Mar 2021 15:01:16 -0400 Subject: [PATCH 51/73] Go fish DONE --- src/main/java/io/zipcoder/casino/GoFish.java | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index 466177c70..18aca0d90 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -29,7 +29,7 @@ public void playGame() { System.out.println("Are you ready to begin? (enter 'yes' or 'y')"); String input = Displays.getStringInput(); Boolean stillPlaying; - //The actual GAME starts here. + //The game setup for if you agre to play starts here while(input.equalsIgnoreCase("yes")||input.equalsIgnoreCase("y")){ newGameState(); for(int i=0; i<7;i++){ @@ -43,18 +43,19 @@ public void playGame() { if(playerScore>0||dealerScore>0){ System.out.println("We already have some books! Crazy!");} stillPlaying=true; + //The actual GAME starts here. while(stillPlaying==true) { //player takes their turn if(stillPlaying==true){ System.out.println("You have "+playerScore+" books."); turnStructure();} //end step for player, checks for winner - if(getCardsLeftInDeck()==0||books.size()==12){ + if(dealer.size()==0||oswald.size()==0||books.size()==12){ stillPlaying=false;} if(stillPlaying==true){turnStructureAI(); System.out.println("The dealer has "+dealerScore+" books.");} //end step for dealer, checks for winner - if(getCardsLeftInDeck()==0||books.size()==12){ + if(dealer.size()==0||oswald.size()==0||books.size()==12){ stillPlaying=false;} } System.out.println(checkWinner()); @@ -101,6 +102,7 @@ public void turnStructure(){ String input=""; while (takeAnotherTurn) { System.out.print(seeHand(oswald)); + if(books.size()>0){System.out.println(showBooks());} System.out.println("Alright, Go fish!"); takeAnotherTurn=false; legalchoice=false; @@ -202,7 +204,7 @@ public Boolean gotAnyKings(List hand, String name) { public void takeCards(List taker, List taken, String name) { for(int i=0;i player, String name) { } public String showBooks(){ - String temp=""; + String temp="Completed books so far: "; for(String i:books){ temp=temp.concat(i+", "); } From 09fcd9d28f949786398c382cc05ea83a5cce3da6 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 17:01:02 -0400 Subject: [PATCH 52/73] finalized BlackJackEngine, changed Ace Cards to be public --- .../java/io/zipcoder/casino/BlackJack.java | 16 +- .../io/zipcoder/casino/BlackJackEngine.java | 271 ++++++++++++++++-- src/main/java/io/zipcoder/casino/Card.java | 5 + .../java/io/zipcoder/casino/CardGame.java | 8 +- .../java/io/zipcoder/casino/CardTest.java | 9 + 5 files changed, 286 insertions(+), 23 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index e9be9ce3c..567fc811a 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -48,12 +48,22 @@ public void playerLosePot() { public void hitMe() { dealCards(currentHand); + int currentValue = 0; if(currentHand == playerHand) { - playerTotal += playerHand.get(playerHand.size() - 1).getValue(); + for(int i = 0; i < playerHand.size(); i++) { + currentValue += playerHand.get(i).getValue(); + } + playerTotal = currentValue; } else if(currentHand == playerSplitHand) { - playerSplitTotal += playerSplitHand.get(playerSplitHand.size() - 1).getValue(); + for(int i = 0; i < playerSplitHand.size(); i++) { + currentValue += playerSplitHand.get(i).getValue(); + } + playerSplitTotal = currentValue; } else if(currentHand == dealerHand) { - dealerTotal += dealerHand.get(dealerHand.size() - 1).getValue(); + for(int i = 0; i < dealerHand.size(); i++) { + currentValue += dealerHand.get(i).getValue(); + } + dealerTotal = currentValue; } } diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 60a000489..c9aaa6f9f 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -3,26 +3,20 @@ import io.zipcoder.casino.utilities.Console; public class BlackJackEngine { + Player player; - public static void main(String[] args) { - BlackJackEngine bj = new BlackJackEngine(); - - bj.blackJack(); + public BlackJackEngine(Player player) { + this.player = player; } public void blackJack() { - boolean gameOn = true; Console console = new Console(System.in, System.out); - PlayerWarehouse.initializePlayers(); - Player player = PlayerWarehouse.currentPlayers.get(100); BlackJack bj = new BlackJack(player); System.out.println(String.format("Hello %s", player.getPlayerName())); System.out.println("Welcome To BlackJack!"); - while (gameOn) { mainBlackJackMenu(bj, player, console); - } } public void mainBlackJackMenu(BlackJack bj, Player player, Console console) { @@ -62,38 +56,47 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { boolean round = true; while(round) { - currentHands(blackJack); + playerTurnHands(blackJack); currentChipCount(player); + currentPot(blackJack); currentTurnIndicator(blackJack); if(blackJack.playerHaveBlackJack() && blackJack.dealerHaveBlackJack() || blackJack.dealerHaveBlackJack() && blackJack.playerHaveBlackJack()) { + currentHands(blackJack); System.out.println(String.format("Both BLACKJACK! You won %s chips.", (blackJack.sizeOfPot))); blackJack.tiedPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); break; } if(blackJack.playerHaveBlackJack()) { + currentHands(blackJack); System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); blackJack.playerWinByBlackJack(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); break; } if(blackJack.dealerHaveBlackJack()) { + currentHands(blackJack); System.out.println("Dealer BLACKJACK! Sorry, better luck next time!"); blackJack.playerLosePot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); break; } - Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t2 - Hold\t3 - Split"); + Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t\t2 - Hold\t\t3 - Double Down\t\t4 - Split"); switch (decision) { case 1: blackJack.hitMe(); + playerChangeAce(blackJack); if(blackJack.playerBust()) { currentHands(blackJack); System.out.println("BUST! Sorry, better luck next time!"); blackJack.playerLosePot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; @@ -102,6 +105,7 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { currentHands(blackJack); System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); blackJack.playerWinPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; @@ -111,25 +115,35 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { blackJack.hold(); while (blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal < 16) { blackJack.hitMe(); + dealerChangeAce(blackJack); System.out.println(String.format("Dealer hits and gets a %s", blackJack.dealerHand.get(blackJack.dealerHand.size() - 1))); currentHands(blackJack); } if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { if(blackJack.checkWinner().equals("Player")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); blackJack.playerWinPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; } else if (blackJack.checkWinner().equals("Dealer")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); System.out.println("Sorry, better luck next time!"); blackJack.playerLosePot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; } else if (blackJack.checkWinner().equals("Tie")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); blackJack.tiedPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; @@ -137,6 +151,59 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { } break; case 3: + if(blackJack.playerHand.size() == 2 && (blackJack.playerTotal == 9 || blackJack.playerTotal == 10 || blackJack.playerTotal == 11)) { + blackJack.addToPot(blackJack.sizeOfPot); + blackJack.hitMe(); + playerChangeAce(blackJack); + if (blackJack.playerBust()) { + currentHands(blackJack); + System.out.println("BUST! Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + blackJack.hold(); + } else System.out.println("Can only double down if starting hand equals 9, 10, or 11."); + while (blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal < 16) { + blackJack.hitMe(); + dealerChangeAce(blackJack); + System.out.println(String.format("Dealer hits and gets a %s", blackJack.dealerHand.get(blackJack.dealerHand.size() - 1))); + currentHands(blackJack); + } + if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { + if(blackJack.checkWinner().equals("Player")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); + blackJack.playerWinPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } else if (blackJack.checkWinner().equals("Dealer")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println("Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } else if (blackJack.checkWinner().equals("Tie")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); + blackJack.tiedPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + } + break; + case 4: if(blackJack.playerHand.get(0).getCardName().equals(blackJack.playerHand.get(1).getCardName())) { splitHandStart(blackJack, player, console); round = false; @@ -156,12 +223,13 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) boolean round = true; while(round) { - currentHands(blackJack); + playerTurnHands(blackJack); currentChipCount(player); currentTurnIndicator(blackJack); if(blackJack.playerHaveBlackJack()) { System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); blackJack.playerWinByBlackJack(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); break; @@ -169,14 +237,19 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) if(blackJack.playerSplitHandHaveBlackJack()) { System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); blackJack.playerWinByBlackJack(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); break; } - Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t2 - Hold"); + Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t\t2 - Hold\t\t3 - Double Down"); switch (decision) { case 1: blackJack.hitMe(); + playerChangeAce(blackJack); + if(blackJack.currentHand == blackJack.playerSplitHand) { + playerSplitHandChangeAce(blackJack); + } if(blackJack.playerBust()) { currentHands(blackJack); System.out.println("BUST! Next hand."); @@ -185,15 +258,38 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) if(blackJack.playerSplitHandBust()) { currentHands(blackJack); System.out.println("BUST! Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + if(blackJack.checkWinner().equals("Player") || blackJack.checkSplitWinner().equals("Player")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot * 2))); + blackJack.playerWinPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } else if (blackJack.checkWinner().equals("Dealer") && blackJack.checkSplitWinner().equals("Dealer")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println("Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } else if (blackJack.checkWinner().equals("Tie") || blackJack.checkSplitWinner().equals("Tie")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); + blackJack.tiedPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } round = false; } if(blackJack.dealerBust()) { currentHands(blackJack); System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); blackJack.playerWinPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; @@ -209,28 +305,104 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) break; } blackJack.hold(); + while (blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal < 16) { + blackJack.hitMe(); + dealerChangeAce(blackJack); + System.out.println(String.format("Dealer hits and gets a %s", blackJack.dealerHand.get(blackJack.dealerHand.size() - 1))); + currentHands(blackJack); + } if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { if(blackJack.checkWinner().equals("Player") || blackJack.checkSplitWinner().equals("Player")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); blackJack.playerWinPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; } else if (blackJack.checkWinner().equals("Dealer") && blackJack.checkSplitWinner().equals("Dealer")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); System.out.println("Sorry, better luck next time!"); blackJack.playerLosePot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; } else if (blackJack.checkWinner().equals("Tie") || blackJack.checkSplitWinner().equals("Tie")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); blackJack.tiedPot(); + resetAceValue(blackJack); resetHandAndValues(blackJack); blackJack.clearDiscardAndDeck(); round = false; } } break; + case 3: + blackJack.addToPot(blackJack.sizeOfPot); + blackJack.hitMe(); + playerChangeAce(blackJack); + if(blackJack.currentHand == blackJack.playerSplitHand) { + playerSplitHandChangeAce(blackJack); + } + if(blackJack.playerBust()) { + currentHands(blackJack); + System.out.println("BUST! Next hand."); + blackJack.splitHold(); + } + if(blackJack.playerSplitHandBust()) { + currentHands(blackJack); + System.out.println("BUST! Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + if(blackJack.dealerBust()) { + currentHands(blackJack); + System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); + blackJack.playerWinPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + blackJack.hold(); + if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { + if(blackJack.checkWinner().equals("Player")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); + blackJack.playerWinPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } else if (blackJack.checkWinner().equals("Dealer")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println("Sorry, better luck next time!"); + blackJack.playerLosePot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } else if (blackJack.checkWinner().equals("Tie")) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); + blackJack.tiedPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + round = false; + } + } default: System.out.println("Not a valid input"); break; @@ -238,6 +410,17 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) } } + public void playerTurnHands(BlackJack blackJack) { + System.out.println("Dealer current hand:"); + System.out.println(String.format("\t\t\t\t\t=== %s + HIDDEN CARD ===", blackJack.dealerHand.get(0))); + if(!blackJack.playerSplitHand.isEmpty()) { + System.out.println(String.format("\nPlayer current split hand: %s\n", blackJack.playerSplitTotal)); + System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.playerSplitHand)); + } + System.out.println(String.format("\nPlayer current hand: %s\n", blackJack.playerTotal)); + System.out.println(String.format("\t\t\t\t\t=== %s ===\n", blackJack.playerHand)); + } + public void currentHands(BlackJack blackJack) { System.out.println(String.format("Dealer current hand: %s\n",blackJack.dealerTotal)); System.out.println(String.format("\t\t\t\t\t=== %s ===", blackJack.dealerHand)); @@ -249,10 +432,66 @@ public void currentHands(BlackJack blackJack) { System.out.println(String.format("\t\t\t\t\t=== %s ===\n", blackJack.playerHand)); } + public void playerChangeAce(BlackJack blackJack) { + int currentValue = 0; + if (blackJack.playerBust()) { + for (int i = 0; i < blackJack.playerHand.size(); i++) { + if (blackJack.playerHand.get(i).getCardName().equals("A")) { + blackJack.playerHand.get(i).setValue(1); + } + } + for(int i = 0; i < blackJack.playerHand.size(); i++) { + currentValue += blackJack.playerHand.get(i).getValue(); + } + blackJack.playerTotal = currentValue; + } + } + + public void playerSplitHandChangeAce(BlackJack blackJack) { + int currentValue = 0; + if (blackJack.playerBust()) { + for (int i = 0; i < blackJack.playerSplitHand.size(); i++) { + if (blackJack.playerSplitHand.get(i).getCardName().equals("A")) { + blackJack.playerSplitHand.get(i).setValue(1); + } + } + for(int i = 0; i < blackJack.playerSplitHand.size(); i++) { + currentValue += blackJack.playerSplitHand.get(i).getValue(); + } + blackJack.playerSplitTotal = currentValue; + } + } + + public void dealerChangeAce(BlackJack blackJack) { + int currentValue = 0; + if (blackJack.dealerBust()) { + for (int i = 0; i < blackJack.dealerHand.size(); i++) { + if (blackJack.dealerHand.get(i).getCardName().equals("A")) { + blackJack.dealerHand.get(i).setValue(1); + } + } + for(int i = 0; i < blackJack.dealerHand.size(); i++) { + currentValue += blackJack.dealerHand.get(i).getValue(); + } + blackJack.dealerTotal = currentValue; + } + } + + public void resetAceValue(BlackJack blackJack) { + blackJack.AceOfClubs.setValue(11); + blackJack.AceOfDiamonds.setValue(11); + blackJack.AceOfHearts.setValue(11); + blackJack.AceOfSpades.setValue(11); + } + public void currentChipCount(Player player) { System.out.println(String.format("%s : Your current chip count is %7d\n", player.getPlayerName(), player.getChipBalance())); } + public void currentPot(BlackJack blackJack) { + System.out.println(String.format("The current bet is %s\n", blackJack.sizeOfPot)); + } + public void resetHandAndValues(BlackJack blackJack) { blackJack.discardHand(blackJack.playerHand); blackJack.discardHand(blackJack.playerSplitHand); diff --git a/src/main/java/io/zipcoder/casino/Card.java b/src/main/java/io/zipcoder/casino/Card.java index cb9595c31..deaa6f778 100644 --- a/src/main/java/io/zipcoder/casino/Card.java +++ b/src/main/java/io/zipcoder/casino/Card.java @@ -22,10 +22,15 @@ public Integer getValue(){ return cardValue; } + public void setValue(int newValue) { + cardValue = newValue; + } + public String getCardSuit(){ return cardSuit; } + @Override public String toString() { return String.format("%s of %s", cardName, cardSuit); diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGame.java index dddfde905..92e562dee 100644 --- a/src/main/java/io/zipcoder/casino/CardGame.java +++ b/src/main/java/io/zipcoder/casino/CardGame.java @@ -9,7 +9,7 @@ abstract class CardGame implements Game { private ListdiscardPile=new ArrayList(); - private Card AceOfSpades=new Card("A", "Spades", 11); + public Card AceOfSpades=new Card("A", "Spades", 11); private Card TwoOfSpades=new Card("2", "Spades", 2); private Card ThreeOfSpades=new Card("3", "Spades", 3); private Card FourOfSpades=new Card("4", "Spades", 4); @@ -23,7 +23,7 @@ abstract class CardGame implements Game { private Card QueenOfSpades=new Card("Q", "Spades", 10); private Card KingOfSpades=new Card("K", "Spades", 10); - private Card AceOfClubs=new Card("A", "Clubs", 11); + public Card AceOfClubs=new Card("A", "Clubs", 11); private Card TwoOfClubs=new Card("2", "Clubs", 2); private Card ThreeOfClubs=new Card("3", "Clubs", 3); private Card FourOfClubs=new Card("4", "Clubs", 4); @@ -37,7 +37,7 @@ abstract class CardGame implements Game { private Card QueenOfClubs=new Card("Q", "Clubs", 10); private Card KingOfClubs=new Card("K", "Clubs", 10); - private Card AceOfDiamonds=new Card("A", "Diamonds", 11); + public Card AceOfDiamonds=new Card("A", "Diamonds", 11); private Card TwoOfDiamonds=new Card("2", "Diamonds", 2); private Card ThreeOfDiamonds=new Card("3", "Diamonds", 3); private Card FourOfDiamonds=new Card("4", "Diamonds", 4); @@ -51,7 +51,7 @@ abstract class CardGame implements Game { private Card QueenOfDiamonds=new Card("Q", "Diamonds", 10); private Card KingOfDiamonds=new Card("K", "Diamonds", 10); - private Card AceOfHearts=new Card("A", "Hearts", 11); + public Card AceOfHearts=new Card("A", "Hearts", 11); private Card TwoOfHearts=new Card("2", "Hearts", 2); private Card ThreeOfHearts=new Card("3", "Hearts", 3); private Card FourOfHearts=new Card("4", "Hearts", 4); diff --git a/src/test/java/io/zipcoder/casino/CardTest.java b/src/test/java/io/zipcoder/casino/CardTest.java index 0b8aa8fb5..49dce6b5f 100644 --- a/src/test/java/io/zipcoder/casino/CardTest.java +++ b/src/test/java/io/zipcoder/casino/CardTest.java @@ -34,4 +34,13 @@ public void getCardValueTest(){ Integer actual = joker.getValue(); Assert.assertEquals(expected,actual); } + + @Test + public void setCardValueTest(){ + Card joker= new Card("3", "Hearts", 3); + Integer expected = 7; + joker.setValue(7); + Integer actual = joker.getValue(); + Assert.assertEquals(expected,actual); + } } From a1df845c1fb68d39a0993a85fe07fccec8ca425e Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 17:23:37 -0400 Subject: [PATCH 53/73] fixed BlackJackEngine to be able to exit --- src/main/java/io/zipcoder/casino/BlackJackEngine.java | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index c9aaa6f9f..71b909d6d 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -16,11 +16,6 @@ public void blackJack() { System.out.println(String.format("Hello %s", player.getPlayerName())); System.out.println("Welcome To BlackJack!"); - mainBlackJackMenu(bj, player, console); - } - - public void mainBlackJackMenu(BlackJack bj, Player player, Console console) { - boolean validInput = true; while(validInput) { Integer input = console.getIntegerInput("Play? 1 - Yes or 2 - No"); From e4d5d8a9068bc08eb3ff81396d84fe8bbd32c70f Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Thu, 18 Mar 2021 17:28:56 -0400 Subject: [PATCH 54/73] need to break out of craps --- src/main/java/io/zipcoder/casino/Casino.java | 117 +++++++++++++----- .../java/io/zipcoder/casino/CrapsEngine.java | 109 ++++++++-------- .../casino/DisplayMainCasinoScreens.java | 23 ++++ 3 files changed, 171 insertions(+), 78 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index fea19a51a..a059b7df5 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -13,25 +13,43 @@ public class Casino { DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); Console console = new Console(System.in, System.out); - GoFish goFish = new GoFish(); - BlackJackEngine blackJack = new BlackJackEngine(); - CrapsEngine crapsEngine = new CrapsEngine(); - MostOfAKindEngine moak = new MostOfAKindEngine(); +// GoFish goFish = new GoFish(); +// BlackJackEngine blackJack = new BlackJackEngine(); +// CrapsEngine crapsEngine = new CrapsEngine(Player player); +// MostOfAKindEngine moak = new MostOfAKindEngine(); ChipMoneyExchange exchange = new ChipMoneyExchange(); - Player currentPlayer = new Player("gerg", 500); + //Player currentPlayer = new Player("gerg", 500); + public static void main(String[] args) { Casino casino = new Casino(); - casino.run(); + while (true) { + casino.run(); + } } public void run() { + PlayerWarehouse.initializePlayers(); + welcome(); +// casinoScreens.welcomeScreen(); +// while (true) { +// Integer input = console.getIntegerInput(""); +// if (input == 00) { +// userLoginScreen(); +// } else if (input == 99) { +// goodbyeCasinoScreen(); +// } else { +// invalidEntryWelcomeScreen(); +// } +// } + } + public void welcome() { casinoScreens.welcomeScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 00) { - casinoLobbyScreen(); + userLoginScreen(); } else if (input == 99) { goodbyeCasinoScreen(); } else { @@ -40,51 +58,94 @@ public void run() { } } - private void invalidEntryWelcomeScreen() { + public void userLoginScreen() { + casinoScreens.loginOrCreateNew(); + while (true) { + Integer input = console.getIntegerInput(""); + if (input == 1) { + enterUserID(); + } else if (input == 2) { + createNewAccount(); + } else { + System.out.println("Invalid Entry"); + } + } + } + + public void enterUserID() { + casinoScreens.enterUserID(); + while (true) { + Integer input = console.getIntegerInput(""); + if (PlayerWarehouse.currentPlayers.containsKey(input)) { + Player currentPlayer = PlayerWarehouse.currentPlayers.get(input); + casinoLobbyScreen(currentPlayer); + } else if (!PlayerWarehouse.currentPlayers.containsKey(input)) { + createNewAccount(); + } + } + } + + public void createNewAccount() { + String input = console.getStringInput("Enter Name"); + int wallet = console.getIntegerInput("Enter wallet size"); + Player newPlayer = PlayerFactory.createPlayer(input, wallet); + PlayerWarehouse.addPlayer(newPlayer.getPlayerID(), newPlayer); + casinoScreens.accountMade(newPlayer.getPlayerID()); + while (true) { + Integer newInput = console.getIntegerInput(""); + if (newInput == 00) { + casinoLobbyScreen(newPlayer); + } else { + System.out.println("Invalid entry"); + } + } + } + + public void invalidEntryWelcomeScreen() { casinoScreens.invalidEntryWelcomeScreen(); } - private void goodbyeCasinoScreen() { + public void goodbyeCasinoScreen() { casinoScreens.goodbyeCasinoScreen(); System.exit(0); } - private void casinoLobbyScreen() { + public void casinoLobbyScreen(Player currentPlayer) { casinoScreens.casinoLobbyScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - tellerWindow(); + tellerWindow(currentPlayer); } else if (input == 2) { - //I think this is what I need to call... - goFish.playGame(); + //GoFishEngine goFish = new GoFishEngine(currentPlayer); } else if (input == 3) { - //Double check this is right + BlackJackEngine blackJack = new BlackJackEngine(currentPlayer); blackJack.blackJack(); } else if (input == 4) { - //craps + CrapsEngine crapsEngine = new CrapsEngine(currentPlayer); + crapsEngine.craps(); } else if (input == 5) { - //most of a kind + //MostOfAKindEngine moak = new MostOfAKindEngine(currentPlayer); } else if (input == 00) { - goodbyeCasinoScreen(); + run(); } else { casinoLobbyInvalidScreen(); } } } - private void casinoLobbyInvalidScreen() { + public void casinoLobbyInvalidScreen() { casinoScreens.casinoLobbyInvalidScreen(); } - private void tellerWindow() { + public void tellerWindow(Player currentPlayer) { casinoScreens.tellerMainScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - tellerMoneyToChipsScreen(); + tellerMoneyToChipsScreen(currentPlayer); } else if (input == 2) { - cashOutChips(currentPlayer.getChipBalance()); + cashOutChips(currentPlayer.getChipBalance(), currentPlayer); currentPlayer.setChipBalance(0); } else { tellerInvalidMainScreen(); @@ -92,16 +153,16 @@ private void tellerWindow() { } } - private void tellerInvalidMainScreen() { + public void tellerInvalidMainScreen() { casinoScreens.tellerInvalidMainScreen(); } - private void cashOutChips(int chipsCashOut) { + public void cashOutChips(int chipsCashOut, Player currentPlayer) { casinoScreens.tellerChipsToMoneyScreen(chipsCashOut); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - tellerWindow(); + tellerWindow(currentPlayer); } else if (input == 2) { System.exit(0); } else { @@ -110,26 +171,26 @@ private void cashOutChips(int chipsCashOut) { } } - private void tellerMoneyToChipsScreen() { + public void tellerMoneyToChipsScreen(Player currentPlayer) { casinoScreens.tellerMoneyToChipsScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input <= currentPlayer.getWallet()) { int chips = exchange.moneyToChips(input); currentPlayer.setChipBalance(chips); - chipBalanceScreen(currentPlayer.getChipBalance()); + chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer); } else { System.out.println("Invalid Entry"); } } } - private void chipBalanceScreen(int chips) { + public void chipBalanceScreen(int chips, Player currentPlayer) { casinoScreens.howManyChipsScreen(chips); while (true) { Integer input = console.getIntegerInput(""); if (input == 00) { - casinoLobbyScreen(); + casinoLobbyScreen(currentPlayer); } else { System.out.println("Invalid Entry"); } diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index 6ed658ab1..de51312d2 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -4,43 +4,52 @@ import io.zipcoder.casino.utilities.Console; public class CrapsEngine { - Console console = new Console(System.in, System.out); CrapsScreens cScreens = new CrapsScreens(); - Player player = new Player("gerg", 500); - Craps craps = new Craps(player); + DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); + Player player; + public CrapsEngine(Player player) { + this.player = player; + } + + public void craps() { + Craps craps = new Craps(player); + Console console = new Console(System.in, System.out); + + System.out.println(String.format("Hello %s", player.getPlayerName())); + System.out.println("Welcome To Craps!"); - public static void main(String[] args) { - CrapsEngine craps = new CrapsEngine(); - craps.startCrapsGame(); + startCrapsGame(craps, player, console); } - private void startCrapsGame() { + + public void startCrapsGame(Craps craps, Player player, Console console) { cScreens.crapsWelcomeScreen(); - player.setChipBalance(100); + System.out.println(player.getPlayerName()); + System.out.println(player.getChipBalance()); while (true) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { - passOrNotPassRoundOneScreen(craps.getGameRound()); + passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); } else if (input.equals(2)) { - casinoLobby(); + casinoLobby(craps, player, console); } else { - crapsInvalidWelcomeScreen(); + crapsInvalidWelcomeScreen(craps, player, console); } } } - private void crapsInvalidWelcomeScreen() { + public void crapsInvalidWelcomeScreen(Craps craps, Player player, Console console) { cScreens.crapsInvalidWelcomeScreen(); } //TEMPORARY - private void casinoLobby() { - System.exit(0); + public void casinoLobby(Craps craps, Player player, Console console) { + } - private void passOrNotPassRoundOneScreen(int gameRound) { + public void passOrNotPassRoundOneScreen(int gameRound, Craps craps, Player player, Console console) { craps.setGameRound(1); craps.clearPot(); cScreens.passOrNotPassRoundOneScreen(craps.getGameRound()); @@ -48,44 +57,44 @@ private void passOrNotPassRoundOneScreen(int gameRound) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setBetStatus("Pass"); - betAmountRoundOneScreen(); + betAmountRoundOneScreen(craps, player, console); } else if (input.equals(2)) { craps.setBetStatus("Not Pass"); - betAmountRoundOneScreen(); + betAmountRoundOneScreen(craps, player, console); } else { System.out.println("Please enter 1 or 2"); } } } - private void betAmountRoundOneScreen() { + public void betAmountRoundOneScreen(Craps craps, Player player, Console console) { cScreens.betAmountRoundOneScreen(craps.getGameRound()); while (true) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >= 0) { craps.addToPot(input); - rollTheDice(); + rollTheDice(craps, player, console); } else { - getMoreChips(); + getMoreChips(craps, player, console); } } } - private void getMoreChips() { + public void getMoreChips(Craps craps, Player player, Console console) { cScreens.getMoreChips(); while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(); + casinoLobby(craps, player, console); } else if (input == 1) { - betAmountRoundOneScreen(); + betAmountRoundOneScreen(craps, player, console); } else { System.out.println("Invalid Entry"); } } } - private void rollTheDice() { + public void rollTheDice(Craps craps, Player player, Console console) { cScreens.rollTheDice(); while (true) { Integer input = console.getIntegerInput(""); @@ -93,21 +102,21 @@ private void rollTheDice() { craps.sumOfDice(); if (craps.getBetStatus().equalsIgnoreCase("Pass")) { if (craps.getCurrentSum() == 7 || craps.getCurrentSum() == 11) { - winRollScreen(); + winRollScreen(craps, player, console); } else if (craps.getCurrentSum() == 2 || craps.getCurrentSum() == 3 || craps.getCurrentSum() == 12) { - loseRollScreen(); + loseRollScreen(craps, player, console); } else { craps.setPointer(craps.getCurrentSum()); - rollAgainScreen(); + rollAgainScreen(craps, player, console); } } else if (craps.getBetStatus().equalsIgnoreCase("Not Pass")) { if (craps.getCurrentSum() == 2 || craps.getCurrentSum() == 3 || craps.getCurrentSum() == 12) { - winRollScreen(); + winRollScreen(craps, player, console); } else if (craps.getCurrentSum() == 7 || craps.getCurrentSum() == 11) { - loseRollScreen(); + loseRollScreen(craps, player, console); } else { craps.setPointer(craps.getCurrentSum()); - rollAgainScreen(); + rollAgainScreen(craps, player, console); } } } else { @@ -116,79 +125,79 @@ private void rollTheDice() { } } - private void loseRollScreen() { + public void loseRollScreen(Craps craps, Player player, Console console) { cScreens.loseRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); while (true) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setGameRound(1); - passOrNotPassRoundOneScreen(craps.getGameRound()); + passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); } else if (input.equals(2)) { - goodLuckScreen(); + goodLuckScreen(craps, player, console); } else { System.out.println("Invalid Entry"); } } } - private void goodLuckScreen() { + public void goodLuckScreen(Craps craps, Player player, Console console) { cScreens.leaveCrapsScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(); + casinoLobby(craps, player, console); } else { System.out.println("Invalid Entry"); } } } - private void winRollScreen() { + public void winRollScreen(Craps craps, Player player, Console console) { cScreens.winRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); craps.playerWinsPot(craps.getPot()); while (true) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setGameRound(1); - passOrNotPassRoundOneScreen(craps.getGameRound()); + passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); } else if (input.equals(2)) { - goodLuckScreen(); + goodLuckScreen(craps, player, console); } else { System.out.println("Invalid Entry"); } } } - private void rollAgainScreen() { + public void rollAgainScreen(Craps craps, Player player, Console console) { cScreens.passOrNotPassRoundTwoScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); while (true) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setBetStatus("Pass"); - rollAgainBetScreen(); + rollAgainBetScreen(craps, player, console); } else if (input.equals(2)) { craps.setBetStatus("Not Pass"); - rollAgainBetScreen(); + rollAgainBetScreen(craps, player, console); } else { System.out.println("Please enter 1 or 2"); } } } - private void rollAgainBetScreen() { + public void rollAgainBetScreen(Craps craps, Player player, Console console) { cScreens.rollAgainBetScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); while (true) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >=0) { craps.addToPot(input); - rollTheDiceOnward(); + rollTheDiceOnward(craps, player, console); } else { System.out.println("Insufficient Chips"); } } } - private void rollTheDiceOnward() { + private void rollTheDiceOnward(Craps craps, Player player, Console console) { craps.setGameRound(2); cScreens.rollAgainOnward(craps.getGameRound(),craps.getBetStatus(), craps.getPot(), craps.getPointer()); while (true) { @@ -197,19 +206,19 @@ private void rollTheDiceOnward() { craps.sumOfDice(); if (craps.getBetStatus().equalsIgnoreCase("Pass")) { if (craps.getCurrentSum() == craps.getPointer()) { - winRollScreen(); + winRollScreen(craps, player, console); } else if (craps.getCurrentSum() == 7) { - loseRollScreen(); + loseRollScreen(craps, player, console); } else { - rollAgainBetScreen(); + rollAgainBetScreen(craps, player, console); } } else if (craps.getBetStatus().equalsIgnoreCase("Not Pass")) { if (craps.getCurrentSum() == 7) { - winRollScreen(); + winRollScreen(craps, player, console); } else if (craps.getCurrentSum() == craps.getPointer()) { - loseRollScreen(); + loseRollScreen(craps, player, console); } else { - rollAgainBetScreen(); + rollAgainBetScreen(craps, player, console); } } } else { diff --git a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java index c994b67ba..1e454723b 100644 --- a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java +++ b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java @@ -125,4 +125,27 @@ public void howManyChipsScreen (int cashIn) { println(" 00: Casino Lobby "); println(" "); } + + public void loginOrCreateNew() { + println(" "); + println(" 1: Login "); + println(" "); + println(" 2: Create User "); + println(" "); + } + + public void enterUserID() { + println(" "); + println(" Enter ID number "); + println(" "); + } + + public void accountMade(int playerId) { + println(" Thanks for joining! "); + println(" Your ID number is: "); + println(" "); + println(" %s ", playerId); + println(" "); + println(" 00: Enter Casino "); + } } From 95d3d1cf394f44f08642c1f1a628efd2f0420efc Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 17:42:38 -0400 Subject: [PATCH 55/73] actually fixed BlackJackEngine --- src/main/java/io/zipcoder/casino/BlackJackEngine.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 71b909d6d..53c435e15 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -4,6 +4,7 @@ public class BlackJackEngine { Player player; + Casino casino = new Casino(); public BlackJackEngine(Player player) { this.player = player; @@ -33,10 +34,10 @@ public void blackJack() { bj.addToPot(bet); bj.playGame(); roundStart(bj, player, console); - validInput = false; break; case 2: System.out.println("Good bye!"); + casino.casinoLobbyScreen(player); validInput = false; break; default: From 8b1b679d199a53d62304177b3dd84ad2a2fc6c83 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 20:23:59 -0400 Subject: [PATCH 56/73] bug fix on BJE --- src/main/java/io/zipcoder/casino/BlackJackEngine.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 53c435e15..048a664e5 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -298,7 +298,6 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) } if(blackJack.currentHand == blackJack.playerSplitHand) { blackJack.hold(); - break; } blackJack.hold(); while (blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal < 16) { From f0193885a3defbae41b1f1109d71af11254688c8 Mon Sep 17 00:00:00 2001 From: gregdon13 <71530110+gregdon13@users.noreply.github.com> Date: Thu, 18 Mar 2021 20:25:53 -0400 Subject: [PATCH 57/73] Integrated games. This version has bugs in GoFish --- src/main/java/io/zipcoder/casino/Casino.java | 12 +-- .../java/io/zipcoder/casino/CrapsEngine.java | 13 +-- .../casino/DisplayMainCasinoScreens.java | 2 +- .../io/zipcoder/casino/MostOfAKindEngine.java | 84 ++++++++++--------- 4 files changed, 61 insertions(+), 50 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index a059b7df5..e003bfcda 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -18,18 +18,18 @@ public class Casino { // CrapsEngine crapsEngine = new CrapsEngine(Player player); // MostOfAKindEngine moak = new MostOfAKindEngine(); ChipMoneyExchange exchange = new ChipMoneyExchange(); - //Player currentPlayer = new Player("gerg", 500); + public static void main(String[] args) { Casino casino = new Casino(); + PlayerWarehouse.initializePlayers(); while (true) { casino.run(); } } public void run() { - PlayerWarehouse.initializePlayers(); welcome(); // casinoScreens.welcomeScreen(); // while (true) { @@ -117,7 +117,8 @@ public void casinoLobbyScreen(Player currentPlayer) { if (input == 1) { tellerWindow(currentPlayer); } else if (input == 2) { - //GoFishEngine goFish = new GoFishEngine(currentPlayer); + GoFish goFish = new GoFish(currentPlayer); + goFish.playGame(); } else if (input == 3) { BlackJackEngine blackJack = new BlackJackEngine(currentPlayer); blackJack.blackJack(); @@ -125,7 +126,8 @@ public void casinoLobbyScreen(Player currentPlayer) { CrapsEngine crapsEngine = new CrapsEngine(currentPlayer); crapsEngine.craps(); } else if (input == 5) { - //MostOfAKindEngine moak = new MostOfAKindEngine(currentPlayer); + MostOfAKindEngine moak = new MostOfAKindEngine(currentPlayer); + moak.moak(); } else if (input == 00) { run(); } else { @@ -164,7 +166,7 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer) { if (input == 1) { tellerWindow(currentPlayer); } else if (input == 2) { - System.exit(0); + tellerWindow(currentPlayer); } else { System.out.println("Invalid Entry"); } diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index de51312d2..ba4f42dcb 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -5,8 +5,9 @@ public class CrapsEngine { CrapsScreens cScreens = new CrapsScreens(); - DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); +// DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); Player player; + Casino casino = new Casino(); public CrapsEngine(Player player) { @@ -33,7 +34,7 @@ public void startCrapsGame(Craps craps, Player player, Console console) { if (input.equals(1)) { passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); } else if (input.equals(2)) { - casinoLobby(craps, player, console); + casinoLobby(player); } else { crapsInvalidWelcomeScreen(craps, player, console); } @@ -44,9 +45,9 @@ public void crapsInvalidWelcomeScreen(Craps craps, Player player, Console consol cScreens.crapsInvalidWelcomeScreen(); } - //TEMPORARY - public void casinoLobby(Craps craps, Player player, Console console) { + public void casinoLobby(Player player) { + casino.casinoLobbyScreen(player); } public void passOrNotPassRoundOneScreen(int gameRound, Craps craps, Player player, Console console) { @@ -85,7 +86,7 @@ public void getMoreChips(Craps craps, Player player, Console console) { while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(craps, player, console); + casinoLobby(player); } else if (input == 1) { betAmountRoundOneScreen(craps, player, console); } else { @@ -145,7 +146,7 @@ public void goodLuckScreen(Craps craps, Player player, Console console) { while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(craps, player, console); + casinoLobby(player); } else { System.out.println("Invalid Entry"); } diff --git a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java index 1e454723b..0379c95eb 100644 --- a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java +++ b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java @@ -55,7 +55,7 @@ public void casinoLobbyScreen() { println(" 2: *GoFish Room "); println(" 3: BlackJack Room "); println(" 4: Craps Room "); - println(" 5: Poker Dice Room "); + println(" 5: MOAK Room "); println(" 00: Leave "); println(" "); println(" *Don't need chips to play "); diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index 8b1594ca8..8d71f79f6 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -5,42 +5,50 @@ import java.util.ArrayList; public class MostOfAKindEngine { - Console console = new Console(System.in, System.out); + Player player; + Casino casino = new Casino(); MostOfAKindScreens mScreens = new MostOfAKindScreens(); - Player player = new Player("gerg", 500); - MostOfAKindGame moak = new MostOfAKindGame(player); - public static void main(String[] args) { - MostOfAKindEngine moak = new MostOfAKindEngine(); - moak.startMoakGame(); + public MostOfAKindEngine(Player player) { + this.player = player; } - private void startMoakGame() { + public void moak() { + MostOfAKindGame moak = new MostOfAKindGame(player); + Console console = new Console(System.in, System.out); + + System.out.println(String.format("Hello %s", player.getPlayerName())); + System.out.println("Welcome To Most Of A Kind!"); + + startMoakGame(moak, player, console); + } + + private void startMoakGame(MostOfAKindGame moak, Player player, Console console) { mScreens.welcomeMoakScreen(); player.setChipBalance(100); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - anteUpScreen(); + anteUpScreen(moak, player, console); } else if (input == 2) { - casinoLobby(); + casinoLobby(moak, player, console); } else { - welcomeInvalidScreen(); + welcomeInvalidScreen(moak, player, console); } } } //PLACEHOLDER - private void casinoLobby() { - System.exit(0); + private void casinoLobby(MostOfAKindGame moak, Player player, Console console) { + casino.casinoLobbyScreen(player); } - private void welcomeInvalidScreen() { + private void welcomeInvalidScreen(MostOfAKindGame moak, Player player, Console console) { mScreens.welcomeInvalidMoakScreen(); } //Takes 5 chips, makes dealer and player hands - private void anteUpScreen() { + private void anteUpScreen(MostOfAKindGame moak, Player player, Console console) { moak.clearPot(); moak.clearPlayerHand(); moak.clearDealerHand(); @@ -49,12 +57,12 @@ private void anteUpScreen() { Integer input = console.getIntegerInput(""); if (input == 1) { if (player.getChipBalance() < 10) { - needMoreChipsScreen(); + needMoreChipsScreen(moak, player, console); } else { moak.anteUp(); moak.makePlayerHand(5); moak.makeDealerHand(5); - firstRollScreen(moak.getPot(), moak.getPlayerHand()); + firstRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); } } else { System.out.println("Invalid Entry"); @@ -62,46 +70,46 @@ private void anteUpScreen() { } } - private void needMoreChipsScreen() { + private void needMoreChipsScreen(MostOfAKindGame moak, Player player, Console console) { mScreens.needMoreChipsScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(); + casinoLobby(moak, player, console); } else { System.out.println("Invalid Entry"); } } } - private void firstRollScreen(int pot, ArrayList playerHand) { + private void firstRollScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.firstRollScreen(pot, playerHand); while (true) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >= 0) { moak.addToPot(input); - numberToKeepScreen(moak.getPot(), moak.getPlayerHand()); + numberToKeepScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); } else { - getMoreChips(); + getMoreChips(moak, player, console); } } } - private void getMoreChips() { + private void getMoreChips(MostOfAKindGame moak, Player player, Console console) { mScreens.getMoreChips(); while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(); + casinoLobby(moak, player, console); } else if (input == 1) { - firstRollScreen(moak.getPot(), moak.getPlayerHand()); + firstRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); } else { System.out.println("Invalid Entry"); } } } - private void numberToKeepScreen(int pot, ArrayList playerHand) { + private void numberToKeepScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.numberToKeepScreen(pot, playerHand); while (true) { Integer input = console.getIntegerInput(""); @@ -109,19 +117,19 @@ private void numberToKeepScreen(int pot, ArrayList playerHand) { moak.exchangePlayerDice(input); moak.dealerAINumbersToKeep(moak.getDealerHand()); moak.exchangeDealerDice(moak.dealerMatchingNum); - secondRollScreen(moak.getPot(), moak.getPlayerHand()); + secondRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); } else if (input == 0) { moak.clearPlayerHand(); moak.makePlayerHand(5); moak.dealerAINumbersToKeep(moak.getDealerHand()); - secondRollScreen(moak.getPot(), moak.getPlayerHand()); + secondRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); } else { System.out.println("Invalid Entry"); } } } - private void secondRollScreen(int pot, ArrayList playerHand) { + private void secondRollScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.secondRollScreen(pot, playerHand); while (true) { Integer input = console.getIntegerInput(""); @@ -129,50 +137,50 @@ private void secondRollScreen(int pot, ArrayList playerHand) { moak.addToPot(input); moak.playerNumOfMatches(playerHand); if (moak.checkWinner() == true) { - revealHandsPlayerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand()); + revealHandsPlayerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand(), moak, player, console); } else { //catches when dealer wins - revealHandsDealerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand()); + revealHandsDealerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand(), moak, player, console); } } } } - private void revealHandsDealerWins(int pot, ArrayList playerHand, ArrayList dealerHand) { + private void revealHandsDealerWins(int pot, ArrayList playerHand, ArrayList dealerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.revealHandsDealerWins(pot, playerHand, dealerHand); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - anteUpScreen(); + anteUpScreen(moak, player, console); } else if (input == 2) { - goodbyeScreen(); + goodbyeScreen(moak, player, console); } else { System.out.println("Invalid Entry"); } } } - private void revealHandsPlayerWins(int pot, ArrayList playerHand, ArrayList dealerHand) { + private void revealHandsPlayerWins(int pot, ArrayList playerHand, ArrayList dealerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.revealHandsPlayerWins(pot, playerHand, dealerHand); moak.playerWinsPot(moak.getPot()); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { - anteUpScreen(); + anteUpScreen(moak, player, console); } else if (input == 2) { - goodbyeScreen(); + goodbyeScreen(moak, player, console); } else { System.out.println("Invalid Entry"); } } } - private void goodbyeScreen() { + private void goodbyeScreen(MostOfAKindGame moak, Player player, Console console) { mScreens.goodbyeScreen(); while (true) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(); + casinoLobby(moak, player, console); } else { System.out.println("Invalid Entry"); } From 45cc8f689caecb34aedbae1fc5db1b90b8f8ef70 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Thu, 18 Mar 2021 21:01:06 -0400 Subject: [PATCH 58/73] ALL DONE GO FISH --- src/main/java/io/zipcoder/casino/GoFish.java | 36 +++++++++++--------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index 18aca0d90..7b5ab190e 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Locale; import java.util.Random; public class GoFish extends CardGame { @@ -44,18 +45,18 @@ public void playGame() { System.out.println("We already have some books! Crazy!");} stillPlaying=true; //The actual GAME starts here. - while(stillPlaying==true) { + while(stillPlaying) { //player takes their turn - if(stillPlaying==true){ + if(stillPlaying){ System.out.println("You have "+playerScore+" books."); turnStructure();} //end step for player, checks for winner if(dealer.size()==0||oswald.size()==0||books.size()==12){ stillPlaying=false;} - if(stillPlaying==true){turnStructureAI(); + if(stillPlaying){turnStructureAI(); System.out.println("The dealer has "+dealerScore+" books.");} //end step for dealer, checks for winner - if(dealer.size()==0||oswald.size()==0||books.size()==12){ + if(dealer.size()<1||oswald.size()<1||books.size()==12){ stillPlaying=false;} } System.out.println(checkWinner()); @@ -100,7 +101,7 @@ public void turnStructure(){ Boolean legalchoice=false; Boolean takeAnotherTurn=true; String input=""; - while (takeAnotherTurn) { + while (takeAnotherTurn&&oswald.size()>0) { System.out.print(seeHand(oswald)); if(books.size()>0){System.out.println(showBooks());} System.out.println("Alright, Go fish!"); @@ -109,6 +110,7 @@ public void turnStructure(){ input=""; while (!legalchoice) { input = Displays.getStringInput(); + input=input.toUpperCase(); legalchoice = true; if (!gotAnyKings(oswald, input)) { System.out.println("You can only pick card names you have in hand"); @@ -127,14 +129,14 @@ public void turnStructure(){ System.out.println("Whoops! No bites, better draw!"); dealCards(oswald); System.out.println("You drew: "+showCard(oswald, oswald.size()-1)); - if(completeSet(oswald, oswald.get(oswald.size()-1).getCardName())){ - playerScore++; - System.out.println("Congrats, you closed a book!"); - } if(drawAnyKings(oswald,input)){ takeAnotherTurn=true; System.out.println("You caught a fish! You get another turn!"); } + if(completeSet(oswald, oswald.get(oswald.size()-1).getCardName())){ + playerScore++; + System.out.println("Congrats, you closed a book!"); + } } } System.out.println("Turn over!"); @@ -143,7 +145,7 @@ public void turnStructure(){ public void turnStructureAI(){ Boolean takeAnotherTurn=true; String input=""; - while (takeAnotherTurn) { + while (takeAnotherTurn&&dealer.size()>0) { System.out.println("Okay, now it's the dealer's turn!"); takeAnotherTurn=false; Random r=new Random(); @@ -162,14 +164,14 @@ public void turnStructureAI(){ } else { dealCards(dealer); System.out.println("You didn't! Dealer draws a "+showCard(dealer, dealer.size()-1)+"!"); - if(completeSet(dealer, dealer.get(dealer.size()-1).getCardName())){ - dealerScore++; - System.out.println("Dealer closes a book!"); - } if(drawAnyKings(dealer,input)){ takeAnotherTurn=true; System.out.println("Dealer drew a fish! They get another turn!"); } + if(completeSet(dealer, dealer.get(dealer.size()-1).getCardName())){ + dealerScore++; + System.out.println("Dealer closes a book!"); + } } } System.out.println("Dealer's turn over!"); @@ -195,7 +197,7 @@ public String seeHand(List player){ public Boolean gotAnyKings(List hand, String name) { for(Card i:hand){ - if(name.equalsIgnoreCase(i.getCardName())){ + if(name.equals(i.getCardName())){ return true; } } @@ -204,7 +206,7 @@ public Boolean gotAnyKings(List hand, String name) { public void takeCards(List taker, List taken, String name) { for(int i=0;i taker, List taken, String name) { } public Boolean drawAnyKings(List player, String name) { - if(name.equalsIgnoreCase(player.get(player.size()-1).getCardName())){ + if(name.equals(player.get(player.size()-1).getCardName())){ return true; } return false; From 624755257a9e85ac1f6fc473ec8b0676d13e4dd3 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 21:08:25 -0400 Subject: [PATCH 59/73] refactored BlackJackEngine --- .../io/zipcoder/casino/BlackJackEngine.java | 220 +++++++----------- 1 file changed, 88 insertions(+), 132 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 048a664e5..4dd252b7f 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -52,35 +52,22 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { boolean round = true; while(round) { - playerTurnHands(blackJack); - currentChipCount(player); - currentPot(blackJack); - currentTurnIndicator(blackJack); + roundStartOperations(blackJack, player); if(blackJack.playerHaveBlackJack() && blackJack.dealerHaveBlackJack() || blackJack.dealerHaveBlackJack() && blackJack.playerHaveBlackJack()) { currentHands(blackJack); System.out.println(String.format("Both BLACKJACK! You won %s chips.", (blackJack.sizeOfPot))); - blackJack.tiedPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerTiesPot(blackJack); break; } if(blackJack.playerHaveBlackJack()) { currentHands(blackJack); - System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); - blackJack.playerWinByBlackJack(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsByBlackJack(blackJack); break; } if(blackJack.dealerHaveBlackJack()) { currentHands(blackJack); System.out.println("Dealer BLACKJACK! Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); break; } Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t\t2 - Hold\t\t3 - Double Down\t\t4 - Split"); @@ -91,19 +78,13 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { if(blackJack.playerBust()) { currentHands(blackJack); System.out.println("BUST! Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); round = false; } if(blackJack.dealerBust()) { currentHands(blackJack); System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsPot(blackJack); round = false; } break; @@ -117,31 +98,16 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { } if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { if(blackJack.checkWinner().equals("Player")) { - System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); - currentHands(blackJack); - System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + finalHandWin(blackJack); + playerWinsPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Dealer")) { - System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); - currentHands(blackJack); - System.out.println("Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + finalHandLose(blackJack); + playerLosesPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Tie")) { - System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); - currentHands(blackJack); - System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); - blackJack.tiedPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + finalHandTie(blackJack); + playerTiesPot(blackJack); round = false; } } @@ -154,10 +120,7 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { if (blackJack.playerBust()) { currentHands(blackJack); System.out.println("BUST! Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); round = false; } blackJack.hold(); @@ -170,31 +133,16 @@ public void roundStart(BlackJack blackJack, Player player, Console console) { } if(blackJack.currentHand == blackJack.dealerHand && blackJack.dealerTotal >= 16) { if(blackJack.checkWinner().equals("Player")) { - System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); - currentHands(blackJack); - System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + finalHandWin(blackJack); + playerWinsPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Dealer")) { - System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); - currentHands(blackJack); - System.out.println("Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + finalHandLose(blackJack); + playerLosesPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Tie")) { - System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); - currentHands(blackJack); - System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); - blackJack.tiedPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + finalHandTie(blackJack); + playerTiesPot(blackJack); round = false; } } @@ -219,23 +167,13 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) boolean round = true; while(round) { - playerTurnHands(blackJack); - currentChipCount(player); - currentTurnIndicator(blackJack); + roundStartOperations(blackJack, player); if(blackJack.playerHaveBlackJack()) { - System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); - blackJack.playerWinByBlackJack(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsByBlackJack(blackJack); break; } if(blackJack.playerSplitHandHaveBlackJack()) { - System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); - blackJack.playerWinByBlackJack(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsByBlackJack(blackJack); break; } Integer decision = console.getIntegerInput("What would you like to do?\n1 - Hit\t\t2 - Hold\t\t3 - Double Down"); @@ -258,36 +196,24 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot * 2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsPot(blackJack); } else if (blackJack.checkWinner().equals("Dealer") && blackJack.checkSplitWinner().equals("Dealer")) { System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println("Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); } else if (blackJack.checkWinner().equals("Tie") || blackJack.checkSplitWinner().equals("Tie")) { System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); - blackJack.tiedPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerTiesPot(blackJack); } round = false; } if(blackJack.dealerBust()) { currentHands(blackJack); System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsPot(blackJack); round = false; } break; @@ -311,28 +237,19 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Dealer") && blackJack.checkSplitWinner().equals("Dealer")) { System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println("Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Tie") || blackJack.checkSplitWinner().equals("Tie")) { System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); - blackJack.tiedPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerTiesPot(blackJack); round = false; } } @@ -352,19 +269,13 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) if(blackJack.playerSplitHandBust()) { currentHands(blackJack); System.out.println("BUST! Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); round = false; } if(blackJack.dealerBust()) { currentHands(blackJack); System.out.println(String.format("Congrats! Dealer BUST! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsPot(blackJack); round = false; } blackJack.hold(); @@ -373,28 +284,19 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); - blackJack.playerWinPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerWinsPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Dealer")) { System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println("Sorry, better luck next time!"); - blackJack.playerLosePot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerLosesPot(blackJack); round = false; } else if (blackJack.checkWinner().equals("Tie")) { System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); currentHands(blackJack); System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); - blackJack.tiedPot(); - resetAceValue(blackJack); - resetHandAndValues(blackJack); - blackJack.clearDiscardAndDeck(); + playerTiesPot(blackJack); round = false; } } @@ -405,6 +307,53 @@ public void splitHandStart(BlackJack blackJack, Player player, Console console) } } + private void playerWinsByBlackJack(BlackJack blackJack) { + System.out.println(String.format("BLACKJACK! You won %s chips.", (blackJack.sizeOfPot*3))); + blackJack.playerWinByBlackJack(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } + + private void playerLosesPot(BlackJack blackJack) { + blackJack.playerLosePot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } + + private void playerWinsPot(BlackJack blackJack) { + blackJack.playerWinPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } + + private void playerTiesPot(BlackJack blackJack) { + blackJack.tiedPot(); + resetAceValue(blackJack); + resetHandAndValues(blackJack); + blackJack.clearDiscardAndDeck(); + } + + private void finalHandTie(BlackJack blackJack) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("TIED! You won %s chips.", blackJack.sizeOfPot)); + } + + private void finalHandLose(BlackJack blackJack) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println("Sorry, better luck next time!"); + } + + private void finalHandWin(BlackJack blackJack) { + System.out.println("\n\t\t\t\t\t**********FINAL HANDS**********\t\t\t\t\t\n"); + currentHands(blackJack); + System.out.println(String.format("Congrats! You won %s chips.", (blackJack.sizeOfPot*2))); + } + public void playerTurnHands(BlackJack blackJack) { System.out.println("Dealer current hand:"); System.out.println(String.format("\t\t\t\t\t=== %s + HIDDEN CARD ===", blackJack.dealerHand.get(0))); @@ -505,5 +454,12 @@ public void currentTurnIndicator(BlackJack blackJack) { System.out.println("Turn to act : *** Dealer ***"); } } + + public void roundStartOperations(BlackJack blackJack, Player player) { + playerTurnHands(blackJack); + currentChipCount(player); + currentPot(blackJack); + currentTurnIndicator(blackJack); + } } From 8bd39e36c39c4fc8ac765646ec0c0878248f2713 Mon Sep 17 00:00:00 2001 From: gregdon13 <71530110+gregdon13@users.noreply.github.com> Date: Thu, 18 Mar 2021 21:08:56 -0400 Subject: [PATCH 60/73] teller window fixed --- src/main/java/io/zipcoder/casino/Casino.java | 9 +++++---- src/main/java/io/zipcoder/casino/ChipMoneyExchange.java | 1 + src/main/java/io/zipcoder/casino/CrapsEngine.java | 4 ++-- src/main/java/io/zipcoder/casino/MostOfAKindEngine.java | 6 ++++-- 4 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index e003bfcda..33edfe7f1 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -80,7 +80,8 @@ public void enterUserID() { Player currentPlayer = PlayerWarehouse.currentPlayers.get(input); casinoLobbyScreen(currentPlayer); } else if (!PlayerWarehouse.currentPlayers.containsKey(input)) { - createNewAccount(); + System.out.println("Invalid ID"); + userLoginScreen(); } } } @@ -166,7 +167,7 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer) { if (input == 1) { tellerWindow(currentPlayer); } else if (input == 2) { - tellerWindow(currentPlayer); + casinoLobbyScreen(currentPlayer); } else { System.out.println("Invalid Entry"); } @@ -179,10 +180,10 @@ public void tellerMoneyToChipsScreen(Player currentPlayer) { Integer input = console.getIntegerInput(""); if (input <= currentPlayer.getWallet()) { int chips = exchange.moneyToChips(input); - currentPlayer.setChipBalance(chips); + currentPlayer.getMoreChips(chips); chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer); } else { - System.out.println("Invalid Entry"); + System.out.println("Not enough cash"); } } } diff --git a/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java b/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java index 54e935b12..38ab5e106 100644 --- a/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java +++ b/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java @@ -1,6 +1,7 @@ package io.zipcoder.casino; public class ChipMoneyExchange { + Player player; public int moneyToChips(int cash) { diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index ba4f42dcb..c6ba208ee 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -18,8 +18,8 @@ public void craps() { Craps craps = new Craps(player); Console console = new Console(System.in, System.out); - System.out.println(String.format("Hello %s", player.getPlayerName())); - System.out.println("Welcome To Craps!"); +// System.out.println(String.format("Hello %s", player.getPlayerName())); +// System.out.println("Welcome To Craps!"); startCrapsGame(craps, player, console); } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index 8d71f79f6..ce2e1e212 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -16,7 +16,8 @@ public MostOfAKindEngine(Player player) { public void moak() { MostOfAKindGame moak = new MostOfAKindGame(player); Console console = new Console(System.in, System.out); - +// System.out.println(String.format("Hello %s", player.getPlayerName())); +// System.out.println("Welcome To Most Of A Kind!"); System.out.println(String.format("Hello %s", player.getPlayerName())); System.out.println("Welcome To Most Of A Kind!"); @@ -25,7 +26,8 @@ public void moak() { private void startMoakGame(MostOfAKindGame moak, Player player, Console console) { mScreens.welcomeMoakScreen(); - player.setChipBalance(100); + System.out.println(player.getPlayerName()); + System.out.println(player.getChipBalance()); while (true) { Integer input = console.getIntegerInput(""); if (input == 1) { From 3d78a906876ebdd5c97e51272fe22c2151331c73 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 21:57:01 -0400 Subject: [PATCH 61/73] removed bet method from player --- .../java/io/zipcoder/casino/BlackJack.java | 2 +- .../io/zipcoder/casino/GamblingPlayer.java | 1 - .../io/zipcoder/casino/MostOfAKindGame.java | 2 +- src/main/java/io/zipcoder/casino/Player.java | 3 -- .../java/io/zipcoder/casino/PlayerTest.java | 31 ++++++++++--------- 5 files changed, 18 insertions(+), 21 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index 567fc811a..698662811 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -19,7 +19,7 @@ public BlackJack(Player currentPlayer) { } public void addToPot(int chipsAdded) { - currentPlayer.bet(chipsAdded); + currentPlayer.wageMoney(chipsAdded); sizeOfPot += chipsAdded; } diff --git a/src/main/java/io/zipcoder/casino/GamblingPlayer.java b/src/main/java/io/zipcoder/casino/GamblingPlayer.java index 958d20b70..b7d7d17c6 100644 --- a/src/main/java/io/zipcoder/casino/GamblingPlayer.java +++ b/src/main/java/io/zipcoder/casino/GamblingPlayer.java @@ -6,5 +6,4 @@ public interface GamblingPlayer { void cashOut(); void getMoreChips(int buyAmount); void winChips(int chipsWon); - void bet(int amount); } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 1360b891f..3c2f53adb 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -174,7 +174,7 @@ public void dealerAINumbersToKeep(ArrayList dealerHand) { } public void anteUp() { - currentPlayer.bet(5); + currentPlayer.wageMoney(5); pot += 5; } diff --git a/src/main/java/io/zipcoder/casino/Player.java b/src/main/java/io/zipcoder/casino/Player.java index 448601af1..6c7a5277a 100644 --- a/src/main/java/io/zipcoder/casino/Player.java +++ b/src/main/java/io/zipcoder/casino/Player.java @@ -69,7 +69,4 @@ public void winChips(int chipsWon) { chipBalance += chipsWon; } - public void bet(int amount) { - chipBalance -= amount; - } } diff --git a/src/test/java/io/zipcoder/casino/PlayerTest.java b/src/test/java/io/zipcoder/casino/PlayerTest.java index a3690a18b..59c83ce67 100644 --- a/src/test/java/io/zipcoder/casino/PlayerTest.java +++ b/src/test/java/io/zipcoder/casino/PlayerTest.java @@ -133,6 +133,22 @@ public void wageMoneyTest() { Assert.assertEquals(expected, actual); } + @Test + public void wageMoneyNegativeTest() { + //Given: + Player gamblingAddict = new Player(name, stash); + gamblingAddict.setChipBalance(2500); + int betAmount = -500; + + //When: + int expected = 2500; + gamblingAddict.wageMoney(betAmount); + int actual = gamblingAddict.getChipBalance(); + + //Then: + Assert.assertEquals(expected, actual); + } + @Test public void cashOutTest() { //Given: @@ -210,19 +226,4 @@ public void winChipsTest() { Assert.assertEquals(expected, actual); } - @Test - public void betTest() { - //Given: - Player gamblingAddict = new Player(name, stash); - gamblingAddict.setChipBalance(5000); - int betAmount = 250; - - //When: - int expected = 4750; - gamblingAddict.bet(betAmount); - int actual = gamblingAddict.getChipBalance(); - - //Then: - Assert.assertEquals(expected, actual); - } } \ No newline at end of file From 2c84b285349d93b36e709075817c646c48293e0e Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Thu, 18 Mar 2021 22:37:18 -0400 Subject: [PATCH 62/73] minor user prompt edits --- src/main/java/io/zipcoder/casino/GoFish.java | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index 7b5ab190e..a888a7c20 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -47,16 +47,13 @@ public void playGame() { //The actual GAME starts here. while(stillPlaying) { //player takes their turn - if(stillPlaying){ - System.out.println("You have "+playerScore+" books."); - turnStructure();} + if(stillPlaying){ turnStructure();} //end step for player, checks for winner if(dealer.size()==0||oswald.size()==0||books.size()==12){ stillPlaying=false;} - if(stillPlaying){turnStructureAI(); - System.out.println("The dealer has "+dealerScore+" books.");} + if(stillPlaying){turnStructureAI();} //end step for dealer, checks for winner - if(dealer.size()<1||oswald.size()<1||books.size()==12){ + if(dealer.size()==0||oswald.size()==0||books.size()==12){ stillPlaying=false;} } System.out.println(checkWinner()); @@ -67,6 +64,8 @@ public void playGame() { } public String checkWinner() { + if(oswald.size()==0){System.out.println("The game ends! Your out of cards!");} + if(dealer.size()==0){System.out.println("The game ends! The dealer is out of cards!");} if(dealerScore>playerScore){return "Dealer wins! Sorry....";} else return "You win! Congrats!"; } @@ -103,7 +102,9 @@ public void turnStructure(){ String input=""; while (takeAnotherTurn&&oswald.size()>0) { System.out.print(seeHand(oswald)); - if(books.size()>0){System.out.println(showBooks());} + if(books.size()>0){System.out.println(showBooks()); + System.out.println("You have "+playerScore+" books."); + System.out.println("The dealer has "+dealerScore+" books.");} System.out.println("Alright, Go fish!"); takeAnotherTurn=false; legalchoice=false; From 467fdc56bf967c80b10036486a37aa4b156d06d6 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Thu, 18 Mar 2021 22:53:48 -0400 Subject: [PATCH 63/73] just keep runnin runnin and runnin --- .../io/zipcoder/casino/BlackJackEngine.java | 2 - src/main/java/io/zipcoder/casino/Casino.java | 62 +++++---- .../io/zipcoder/casino/MostOfAKindEngine.java | 122 +++++++++++------- .../io/zipcoder/casino/MostOfAKindTests.java | 67 ++++++++++ 4 files changed, 174 insertions(+), 79 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/BlackJackEngine.java index 4dd252b7f..6fe72cefd 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/BlackJackEngine.java @@ -4,7 +4,6 @@ public class BlackJackEngine { Player player; - Casino casino = new Casino(); public BlackJackEngine(Player player) { this.player = player; @@ -37,7 +36,6 @@ public void blackJack() { break; case 2: System.out.println("Good bye!"); - casino.casinoLobbyScreen(player); validInput = false; break; default: diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 33edfe7f1..afa9bccb5 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -13,11 +13,7 @@ public class Casino { DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); Console console = new Console(System.in, System.out); -// GoFish goFish = new GoFish(); -// BlackJackEngine blackJack = new BlackJackEngine(); -// CrapsEngine crapsEngine = new CrapsEngine(Player player); -// MostOfAKindEngine moak = new MostOfAKindEngine(); - ChipMoneyExchange exchange = new ChipMoneyExchange(); + @@ -31,27 +27,19 @@ public static void main(String[] args) { public void run() { welcome(); -// casinoScreens.welcomeScreen(); -// while (true) { -// Integer input = console.getIntegerInput(""); -// if (input == 00) { -// userLoginScreen(); -// } else if (input == 99) { -// goodbyeCasinoScreen(); -// } else { -// invalidEntryWelcomeScreen(); -// } -// } } public void welcome() { casinoScreens.welcomeScreen(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 00) { userLoginScreen(); + getOut = false; } else if (input == 99) { goodbyeCasinoScreen(); + getOut = false; } else { invalidEntryWelcomeScreen(); } @@ -60,12 +48,15 @@ public void welcome() { public void userLoginScreen() { casinoScreens.loginOrCreateNew(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { enterUserID(); + getOut = false; } else if (input == 2) { createNewAccount(); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -74,14 +65,17 @@ public void userLoginScreen() { public void enterUserID() { casinoScreens.enterUserID(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (PlayerWarehouse.currentPlayers.containsKey(input)) { Player currentPlayer = PlayerWarehouse.currentPlayers.get(input); casinoLobbyScreen(currentPlayer); + getOut = false; } else if (!PlayerWarehouse.currentPlayers.containsKey(input)) { System.out.println("Invalid ID"); userLoginScreen(); + getOut = false; } } } @@ -92,10 +86,12 @@ public void createNewAccount() { Player newPlayer = PlayerFactory.createPlayer(input, wallet); PlayerWarehouse.addPlayer(newPlayer.getPlayerID(), newPlayer); casinoScreens.accountMade(newPlayer.getPlayerID()); - while (true) { + boolean getOut = true; + while (getOut) { Integer newInput = console.getIntegerInput(""); if (newInput == 00) { casinoLobbyScreen(newPlayer); + getOut = false; } else { System.out.println("Invalid entry"); } @@ -112,8 +108,9 @@ public void goodbyeCasinoScreen() { } public void casinoLobbyScreen(Player currentPlayer) { - casinoScreens.casinoLobbyScreen(); - while (true) { + boolean playing = true; + while (playing) { + casinoScreens.casinoLobbyScreen(); Integer input = console.getIntegerInput(""); if (input == 1) { tellerWindow(currentPlayer); @@ -130,7 +127,7 @@ public void casinoLobbyScreen(Player currentPlayer) { MostOfAKindEngine moak = new MostOfAKindEngine(currentPlayer); moak.moak(); } else if (input == 00) { - run(); + playing = false; } else { casinoLobbyInvalidScreen(); } @@ -143,13 +140,16 @@ public void casinoLobbyInvalidScreen() { public void tellerWindow(Player currentPlayer) { casinoScreens.tellerMainScreen(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { tellerMoneyToChipsScreen(currentPlayer); + getOut = false; } else if (input == 2) { cashOutChips(currentPlayer.getChipBalance(), currentPlayer); currentPlayer.setChipBalance(0); + getOut = false; } else { tellerInvalidMainScreen(); } @@ -162,12 +162,15 @@ public void tellerInvalidMainScreen() { public void cashOutChips(int chipsCashOut, Player currentPlayer) { casinoScreens.tellerChipsToMoneyScreen(chipsCashOut); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { tellerWindow(currentPlayer); + getOut = false; } else if (input == 2) { casinoLobbyScreen(currentPlayer); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -175,13 +178,16 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer) { } public void tellerMoneyToChipsScreen(Player currentPlayer) { + ChipMoneyExchange exchange = new ChipMoneyExchange(); casinoScreens.tellerMoneyToChipsScreen(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input <= currentPlayer.getWallet()) { int chips = exchange.moneyToChips(input); currentPlayer.getMoreChips(chips); chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer); + getOut = false; } else { System.out.println("Not enough cash"); } @@ -190,10 +196,12 @@ public void tellerMoneyToChipsScreen(Player currentPlayer) { public void chipBalanceScreen(int chips, Player currentPlayer) { casinoScreens.howManyChipsScreen(chips); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 00) { casinoLobbyScreen(currentPlayer); + getOut = false; } else { System.out.println("Invalid Entry"); } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index ce2e1e212..5d1b90a34 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -16,8 +16,6 @@ public MostOfAKindEngine(Player player) { public void moak() { MostOfAKindGame moak = new MostOfAKindGame(player); Console console = new Console(System.in, System.out); -// System.out.println(String.format("Hello %s", player.getPlayerName())); -// System.out.println("Welcome To Most Of A Kind!"); System.out.println(String.format("Hello %s", player.getPlayerName())); System.out.println("Welcome To Most Of A Kind!"); @@ -28,12 +26,14 @@ private void startMoakGame(MostOfAKindGame moak, Player player, Console console) mScreens.welcomeMoakScreen(); System.out.println(player.getPlayerName()); System.out.println(player.getChipBalance()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { anteUpScreen(moak, player, console); + getOut = false; } else if (input == 2) { - casinoLobby(moak, player, console); + getOut = false; } else { welcomeInvalidScreen(moak, player, console); } @@ -55,76 +55,86 @@ private void anteUpScreen(MostOfAKindGame moak, Player player, Console console) moak.clearPlayerHand(); moak.clearDealerHand(); mScreens.anteUpScreen(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { if (player.getChipBalance() < 10) { - needMoreChipsScreen(moak, player, console); + //needMoreChipsScreen(moak, player, console); + System.out.println("Insufficient Chips"); } else { moak.anteUp(); moak.makePlayerHand(5); moak.makeDealerHand(5); firstRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); } + getOut = false; } else { System.out.println("Invalid Entry"); } } } - private void needMoreChipsScreen(MostOfAKindGame moak, Player player, Console console) { - mScreens.needMoreChipsScreen(); - while (true) { - Integer input = console.getIntegerInput(""); - if (input == 0) { - casinoLobby(moak, player, console); - } else { - System.out.println("Invalid Entry"); - } - } - } +// private void needMoreChipsScreen(MostOfAKindGame moak, Player player, Console console) { +// mScreens.needMoreChipsScreen(); +// boolean getOut = true; +// while (getOut) { +// Integer input = console.getIntegerInput(""); +// if (input == 0) { +// getOut = false; +// } else { +// System.out.println("Invalid Entry"); +// } +// } +// } private void firstRollScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.firstRollScreen(pot, playerHand); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >= 0) { moak.addToPot(input); numberToKeepScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); + getOut = false; } else { - getMoreChips(moak, player, console); + System.out.println("Insufficient Chips");; } } } - private void getMoreChips(MostOfAKindGame moak, Player player, Console console) { - mScreens.getMoreChips(); - while (true) { - Integer input = console.getIntegerInput(""); - if (input == 0) { - casinoLobby(moak, player, console); - } else if (input == 1) { - firstRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); - } else { - System.out.println("Invalid Entry"); - } - } - } +// private void getMoreChips(MostOfAKindGame moak, Player player, Console console) { +// mScreens.getMoreChips(); +// boolean getOut = true; +// while (getOut) { +// Integer input = console.getIntegerInput(""); +// if (input == 0) { +// getOut = false; +// } else if (input == 1) { +// firstRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); +// } else { +// System.out.println("Invalid Entry"); +// } +// } +// } private void numberToKeepScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.numberToKeepScreen(pot, playerHand); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (moak.getPlayerHand().contains(input)) { moak.exchangePlayerDice(input); moak.dealerAINumbersToKeep(moak.getDealerHand()); moak.exchangeDealerDice(moak.dealerMatchingNum); secondRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); + getOut = false; } else if (input == 0) { moak.clearPlayerHand(); moak.makePlayerHand(5); moak.dealerAINumbersToKeep(moak.getDealerHand()); secondRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -133,29 +143,38 @@ private void numberToKeepScreen(int pot, ArrayList playerHand, MostOfAK private void secondRollScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.secondRollScreen(pot, playerHand); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >= 0) { moak.addToPot(input); moak.playerNumOfMatches(playerHand); + moak.dealerNumOfMatches(moak.dealerHand); if (moak.checkWinner() == true) { revealHandsPlayerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand(), moak, player, console); - } else { + getOut = false; + } else if (moak.checkWinner() == false) { //catches when dealer wins revealHandsDealerWins(moak.getPot(), moak.getPlayerHand(), moak.getDealerHand(), moak, player, console); + getOut = false; } + } else { + System.out.println("Insufficient Chips"); } } } private void revealHandsDealerWins(int pot, ArrayList playerHand, ArrayList dealerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.revealHandsDealerWins(pot, playerHand, dealerHand); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { anteUpScreen(moak, player, console); + getOut = false; } else if (input == 2) { - goodbyeScreen(moak, player, console); + System.out.println("Goodbye and good luck!"); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -165,27 +184,30 @@ private void revealHandsDealerWins(int pot, ArrayList playerHand, Array private void revealHandsPlayerWins(int pot, ArrayList playerHand, ArrayList dealerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.revealHandsPlayerWins(pot, playerHand, dealerHand); moak.playerWinsPot(moak.getPot()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { anteUpScreen(moak, player, console); + getOut = false; } else if (input == 2) { - goodbyeScreen(moak, player, console); + System.out.println("Goodbye and good luck!"); + getOut = false; } else { System.out.println("Invalid Entry"); } } } - private void goodbyeScreen(MostOfAKindGame moak, Player player, Console console) { - mScreens.goodbyeScreen(); - while (true) { - Integer input = console.getIntegerInput(""); - if (input == 0) { - casinoLobby(moak, player, console); - } else { - System.out.println("Invalid Entry"); - } - } - } +// private void goodbyeScreen(MostOfAKindGame moak, Player player, Console console) { +// mScreens.goodbyeScreen(); +// while (getOut) { +// Integer input = console.getIntegerInput(""); +// if (input == 0) { +// getOut = false; +// } else { +// System.out.println("Invalid Entry"); +// } +// } +// } } diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 4dc73e014..5b569bd99 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -127,6 +127,73 @@ public void extensiveCheckWinner() { Assert.assertEquals(expected, actual); } + @Test + public void winnerBugTest() { + //Given + ArrayList dealerHand = new ArrayList<>(); + dealerHand.add(1); + dealerHand.add(1); + dealerHand.add(3); + dealerHand.add(1); + dealerHand.add(5); + + ArrayList playerHand = new ArrayList<>(); + playerHand.add(3); + playerHand.add(3); + playerHand.add(5); + playerHand.add(6); + playerHand.add(5); + + //When + yahtzee.playerNumOfMatches(playerHand); + yahtzee.dealerNumOfMatches(dealerHand); + boolean result = yahtzee.checkWinner(); + + + //Then + Assert.assertFalse(result); + } + + @Test + public void playerNumberOfMatches() { + //Given + ArrayList playerHand = new ArrayList<>(); + playerHand.add(3); + playerHand.add(3); + playerHand.add(5); + playerHand.add(6); + playerHand.add(5); + + //When + int expected = 2; + yahtzee.playerNumOfMatches(playerHand); + int actual = yahtzee.getPlayerCount(); + + + //Then + Assert.assertEquals(expected, actual); + } + + @Test + public void dealerNumberOfMatches() { + //Given + ArrayList dealerHand = new ArrayList<>(); + dealerHand.add(1); + dealerHand.add(1); + dealerHand.add(3); + dealerHand.add(1); + dealerHand.add(5); + + //When + int expected = 3; + yahtzee.dealerNumOfMatches(dealerHand); + int actual = yahtzee.getDealerCount(); + + + //Then + Assert.assertEquals(expected, actual); + } + @Test public void makeDealerHand() { //Given From f4155ad7162dd5fa6c71020d175c116a71f5c945 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Thu, 18 Mar 2021 23:05:07 -0400 Subject: [PATCH 64/73] craps is not infinite anymore --- .../java/io/zipcoder/casino/CrapsEngine.java | 67 ++++++++++++------- 1 file changed, 44 insertions(+), 23 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index c6ba208ee..f777fbaf7 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -5,9 +5,8 @@ public class CrapsEngine { CrapsScreens cScreens = new CrapsScreens(); -// DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); Player player; - Casino casino = new Casino(); + //Casino casino = new Casino(); public CrapsEngine(Player player) { @@ -17,10 +16,6 @@ public CrapsEngine(Player player) { public void craps() { Craps craps = new Craps(player); Console console = new Console(System.in, System.out); - -// System.out.println(String.format("Hello %s", player.getPlayerName())); -// System.out.println("Welcome To Craps!"); - startCrapsGame(craps, player, console); } @@ -29,12 +24,14 @@ public void startCrapsGame(Craps craps, Player player, Console console) { cScreens.crapsWelcomeScreen(); System.out.println(player.getPlayerName()); System.out.println(player.getChipBalance()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); + getOut = false; } else if (input.equals(2)) { - casinoLobby(player); + getOut = false; } else { crapsInvalidWelcomeScreen(craps, player, console); } @@ -46,22 +43,25 @@ public void crapsInvalidWelcomeScreen(Craps craps, Player player, Console consol } - public void casinoLobby(Player player) { - casino.casinoLobbyScreen(player); - } +// public void casinoLobby(Player player) { +// casino.casinoLobbyScreen(player); +// } public void passOrNotPassRoundOneScreen(int gameRound, Craps craps, Player player, Console console) { craps.setGameRound(1); craps.clearPot(); cScreens.passOrNotPassRoundOneScreen(craps.getGameRound()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setBetStatus("Pass"); betAmountRoundOneScreen(craps, player, console); + getOut = false; } else if (input.equals(2)) { craps.setBetStatus("Not Pass"); betAmountRoundOneScreen(craps, player, console); + getOut = false; } else { System.out.println("Please enter 1 or 2"); } @@ -70,25 +70,30 @@ public void passOrNotPassRoundOneScreen(int gameRound, Craps craps, Player playe public void betAmountRoundOneScreen(Craps craps, Player player, Console console) { cScreens.betAmountRoundOneScreen(craps.getGameRound()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >= 0) { craps.addToPot(input); rollTheDice(craps, player, console); + getOut = false; } else { getMoreChips(craps, player, console); + getOut = false; } } } public void getMoreChips(Craps craps, Player player, Console console) { cScreens.getMoreChips(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(player); + getOut = false; } else if (input == 1) { betAmountRoundOneScreen(craps, player, console); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -97,7 +102,8 @@ public void getMoreChips(Craps craps, Player player, Console console) { public void rollTheDice(Craps craps, Player player, Console console) { cScreens.rollTheDice(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { craps.sumOfDice(); @@ -120,6 +126,7 @@ public void rollTheDice(Craps craps, Player player, Console console) { rollAgainScreen(craps, player, console); } } + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -128,13 +135,16 @@ public void rollTheDice(Craps craps, Player player, Console console) { public void loseRollScreen(Craps craps, Player player, Console console) { cScreens.loseRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setGameRound(1); passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); + getOut = false; } else if (input.equals(2)) { goodLuckScreen(craps, player, console); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -143,10 +153,11 @@ public void loseRollScreen(Craps craps, Player player, Console console) { public void goodLuckScreen(Craps craps, Player player, Console console) { cScreens.leaveCrapsScreen(); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 0) { - casinoLobby(player); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -156,13 +167,16 @@ public void goodLuckScreen(Craps craps, Player player, Console console) { public void winRollScreen(Craps craps, Player player, Console console) { cScreens.winRollScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus()); craps.playerWinsPot(craps.getPot()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setGameRound(1); passOrNotPassRoundOneScreen(craps.getGameRound(), craps, player, console); + getOut = false; } else if (input.equals(2)) { goodLuckScreen(craps, player, console); + getOut = false; } else { System.out.println("Invalid Entry"); } @@ -171,14 +185,17 @@ public void winRollScreen(Craps craps, Player player, Console console) { public void rollAgainScreen(Craps craps, Player player, Console console) { cScreens.passOrNotPassRoundTwoScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input.equals(1)) { craps.setBetStatus("Pass"); rollAgainBetScreen(craps, player, console); + getOut = false; } else if (input.equals(2)) { craps.setBetStatus("Not Pass"); rollAgainBetScreen(craps, player, console); + getOut = false; } else { System.out.println("Please enter 1 or 2"); } @@ -187,11 +204,13 @@ public void rollAgainScreen(Craps craps, Player player, Console console) { public void rollAgainBetScreen(Craps craps, Player player, Console console) { cScreens.rollAgainBetScreen(craps.getGameRound(), craps.getPot(), craps.getCurrentSum(), craps.getBetStatus(), craps.getPointer()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input <= player.getChipBalance() && input >=0) { craps.addToPot(input); rollTheDiceOnward(craps, player, console); + getOut = false; } else { System.out.println("Insufficient Chips"); } @@ -201,7 +220,8 @@ public void rollAgainBetScreen(Craps craps, Player player, Console console) { private void rollTheDiceOnward(Craps craps, Player player, Console console) { craps.setGameRound(2); cScreens.rollAgainOnward(craps.getGameRound(),craps.getBetStatus(), craps.getPot(), craps.getPointer()); - while (true) { + boolean getOut = true; + while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { craps.sumOfDice(); @@ -222,6 +242,7 @@ private void rollTheDiceOnward(Craps craps, Player player, Console console) { rollAgainBetScreen(craps, player, console); } } + getOut = false; } else { System.out.println("Invalid Entry"); } From bbbe1ea51678db904a006059515c5f2c3761d8e1 Mon Sep 17 00:00:00 2001 From: Abiel Figueroa Date: Thu, 18 Mar 2021 23:12:56 -0400 Subject: [PATCH 65/73] it never ends --- src/main/java/io/zipcoder/casino/GoFish.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/GoFish.java index a888a7c20..2212f8472 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/GoFish.java @@ -1,5 +1,7 @@ package io.zipcoder.casino; +import io.zipcoder.casino.utilities.Console; + import java.util.ArrayList; import java.util.List; import java.util.Locale; @@ -12,6 +14,7 @@ public class GoFish extends CardGame { private List books=new ArrayList(); int playerScore=0; int dealerScore=0; + Console gamecube=new Console(System.in,System.out); public GoFish(Player current){ @@ -27,10 +30,9 @@ public void playGame() { System.out.println("Welcome to Go Fish, "+currentplayer.getPlayerName()); System.out.println("This is a nice, friendly game so don't worry about " + "the chips, okay?"); - System.out.println("Are you ready to begin? (enter 'yes' or 'y')"); - String input = Displays.getStringInput(); + String input = gamecube.getStringInput("Are you ready to begin? (enter 'yes' or 'y')"); Boolean stillPlaying; - //The game setup for if you agre to play starts here + //The game setup for if you agree to play starts here while(input.equalsIgnoreCase("yes")||input.equalsIgnoreCase("y")){ newGameState(); for(int i=0; i<7;i++){ @@ -57,8 +59,7 @@ public void playGame() { stillPlaying=false;} } System.out.println(checkWinner()); - System.out.println("Did you want to play again? (enter 'yes' or 'y')"); - input = Displays.getStringInput(); + input = gamecube.getStringInput("Did you want to play again? (enter 'yes' or 'y')"); } System.out.println("Okay then, take care and thanks for playing!"); } @@ -97,20 +98,19 @@ public void newGameState(){ public void turnStructure(){ - Boolean legalchoice=false; + Boolean legalchoice; Boolean takeAnotherTurn=true; - String input=""; + String input; while (takeAnotherTurn&&oswald.size()>0) { System.out.print(seeHand(oswald)); if(books.size()>0){System.out.println(showBooks()); System.out.println("You have "+playerScore+" books."); System.out.println("The dealer has "+dealerScore+" books.");} - System.out.println("Alright, Go fish!"); takeAnotherTurn=false; legalchoice=false; input=""; while (!legalchoice) { - input = Displays.getStringInput(); + input = gamecube.getStringInput("Alright, go fish!"); input=input.toUpperCase(); legalchoice = true; if (!gotAnyKings(oswald, input)) { From d14fa715ff96f985ea7ff02352803eac497ecf05 Mon Sep 17 00:00:00 2001 From: gregdon13 <71530110+gregdon13@users.noreply.github.com> Date: Thu, 18 Mar 2021 23:15:46 -0400 Subject: [PATCH 66/73] teller window fixed From e44c5cc3f85f722badb375952cf88c98636d77e8 Mon Sep 17 00:00:00 2001 From: gregdon13 <71530110+gregdon13@users.noreply.github.com> Date: Thu, 18 Mar 2021 23:21:19 -0400 Subject: [PATCH 67/73] teller window shows wallet and chip balance --- src/main/java/io/zipcoder/casino/Casino.java | 2 +- .../java/io/zipcoder/casino/DisplayMainCasinoScreens.java | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index afa9bccb5..4e68d5db9 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -179,7 +179,7 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer) { public void tellerMoneyToChipsScreen(Player currentPlayer) { ChipMoneyExchange exchange = new ChipMoneyExchange(); - casinoScreens.tellerMoneyToChipsScreen(); + casinoScreens.tellerMoneyToChipsScreen(currentPlayer.getChipBalance(), currentPlayer.getWallet()); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); diff --git a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java index 0379c95eb..de4127453 100644 --- a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java +++ b/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java @@ -99,7 +99,10 @@ public void tellerInvalidMainScreen() { println(" "); } - public void tellerMoneyToChipsScreen() { + public void tellerMoneyToChipsScreen(int currentChips, int currentWallet) { + println(" "); + println(" Your wallet: %s ", currentWallet); + println(" Your chips: %s ", currentChips); println(" "); println(" How much money would "); println(" you like to exchange? "); From d136d8be09c9e1ee562c95a010bf6b478d33cf24 Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Thu, 18 Mar 2021 23:23:24 -0400 Subject: [PATCH 68/73] updated casino and refactored code --- src/main/java/io/zipcoder/casino/Casino.java | 81 +++++++------------ .../io/zipcoder/casino/MostOfAKindEngine.java | 3 - 2 files changed, 31 insertions(+), 53 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 4e68d5db9..2fc8d75ae 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -1,61 +1,42 @@ package io.zipcoder.casino; - import io.zipcoder.casino.utilities.Console; public class Casino { - /* - Want to double check how to call the engines - Clarify which fields we need for this class - - */ - - - DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); - Console console = new Console(System.in, System.out); - - - - - public static void main(String[] args) { - Casino casino = new Casino(); - PlayerWarehouse.initializePlayers(); - while (true) { - casino.run(); - } - } public void run() { welcome(); } public void welcome() { + DisplayMainCasinoScreens casinoScreens = new DisplayMainCasinoScreens(); + Console console = new Console(System.in, System.out); casinoScreens.welcomeScreen(); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (input == 00) { - userLoginScreen(); + userLoginScreen(casinoScreens, console); getOut = false; } else if (input == 99) { - goodbyeCasinoScreen(); + goodbyeCasinoScreen(casinoScreens); getOut = false; } else { - invalidEntryWelcomeScreen(); + invalidEntryWelcomeScreen(casinoScreens); } } } - public void userLoginScreen() { + public void userLoginScreen(DisplayMainCasinoScreens casinoScreens, Console console) { casinoScreens.loginOrCreateNew(); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { - enterUserID(); + enterUserID(casinoScreens, console); getOut = false; } else if (input == 2) { - createNewAccount(); + createNewAccount(casinoScreens, console); getOut = false; } else { System.out.println("Invalid Entry"); @@ -63,24 +44,24 @@ public void userLoginScreen() { } } - public void enterUserID() { + public void enterUserID(DisplayMainCasinoScreens casinoScreens, Console console) { casinoScreens.enterUserID(); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (PlayerWarehouse.currentPlayers.containsKey(input)) { Player currentPlayer = PlayerWarehouse.currentPlayers.get(input); - casinoLobbyScreen(currentPlayer); + casinoLobbyScreen(currentPlayer, casinoScreens, console); getOut = false; } else if (!PlayerWarehouse.currentPlayers.containsKey(input)) { System.out.println("Invalid ID"); - userLoginScreen(); + userLoginScreen(casinoScreens, console); getOut = false; } } } - public void createNewAccount() { + public void createNewAccount(DisplayMainCasinoScreens casinoScreens, Console console) { String input = console.getStringInput("Enter Name"); int wallet = console.getIntegerInput("Enter wallet size"); Player newPlayer = PlayerFactory.createPlayer(input, wallet); @@ -90,7 +71,7 @@ public void createNewAccount() { while (getOut) { Integer newInput = console.getIntegerInput(""); if (newInput == 00) { - casinoLobbyScreen(newPlayer); + casinoLobbyScreen(newPlayer, casinoScreens, console); getOut = false; } else { System.out.println("Invalid entry"); @@ -98,22 +79,22 @@ public void createNewAccount() { } } - public void invalidEntryWelcomeScreen() { + public void invalidEntryWelcomeScreen(DisplayMainCasinoScreens casinoScreens) { casinoScreens.invalidEntryWelcomeScreen(); } - public void goodbyeCasinoScreen() { + public void goodbyeCasinoScreen(DisplayMainCasinoScreens casinoScreens) { casinoScreens.goodbyeCasinoScreen(); System.exit(0); } - public void casinoLobbyScreen(Player currentPlayer) { + public void casinoLobbyScreen(Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { boolean playing = true; while (playing) { casinoScreens.casinoLobbyScreen(); Integer input = console.getIntegerInput(""); if (input == 1) { - tellerWindow(currentPlayer); + tellerWindow(currentPlayer, casinoScreens, console); } else if (input == 2) { GoFish goFish = new GoFish(currentPlayer); goFish.playGame(); @@ -129,47 +110,47 @@ public void casinoLobbyScreen(Player currentPlayer) { } else if (input == 00) { playing = false; } else { - casinoLobbyInvalidScreen(); + casinoLobbyInvalidScreen(casinoScreens); } } } - public void casinoLobbyInvalidScreen() { + public void casinoLobbyInvalidScreen(DisplayMainCasinoScreens casinoScreens) { casinoScreens.casinoLobbyInvalidScreen(); } - public void tellerWindow(Player currentPlayer) { + public void tellerWindow(Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { casinoScreens.tellerMainScreen(); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { - tellerMoneyToChipsScreen(currentPlayer); + tellerMoneyToChipsScreen(currentPlayer, casinoScreens, console); getOut = false; } else if (input == 2) { - cashOutChips(currentPlayer.getChipBalance(), currentPlayer); + cashOutChips(currentPlayer.getChipBalance(), currentPlayer, casinoScreens, console); currentPlayer.setChipBalance(0); getOut = false; } else { - tellerInvalidMainScreen(); + tellerInvalidMainScreen(casinoScreens); } } } - public void tellerInvalidMainScreen() { + public void tellerInvalidMainScreen(DisplayMainCasinoScreens casinoScreens) { casinoScreens.tellerInvalidMainScreen(); } - public void cashOutChips(int chipsCashOut, Player currentPlayer) { + public void cashOutChips(int chipsCashOut, Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { casinoScreens.tellerChipsToMoneyScreen(chipsCashOut); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (input == 1) { - tellerWindow(currentPlayer); + tellerWindow(currentPlayer, casinoScreens, console); getOut = false; } else if (input == 2) { - casinoLobbyScreen(currentPlayer); + casinoLobbyScreen(currentPlayer, casinoScreens, console); getOut = false; } else { System.out.println("Invalid Entry"); @@ -177,7 +158,7 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer) { } } - public void tellerMoneyToChipsScreen(Player currentPlayer) { + public void tellerMoneyToChipsScreen(Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { ChipMoneyExchange exchange = new ChipMoneyExchange(); casinoScreens.tellerMoneyToChipsScreen(currentPlayer.getChipBalance(), currentPlayer.getWallet()); boolean getOut = true; @@ -186,7 +167,7 @@ public void tellerMoneyToChipsScreen(Player currentPlayer) { if (input <= currentPlayer.getWallet()) { int chips = exchange.moneyToChips(input); currentPlayer.getMoreChips(chips); - chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer); + chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer, casinoScreens, console); getOut = false; } else { System.out.println("Not enough cash"); @@ -194,13 +175,13 @@ public void tellerMoneyToChipsScreen(Player currentPlayer) { } } - public void chipBalanceScreen(int chips, Player currentPlayer) { + public void chipBalanceScreen(int chips, Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { casinoScreens.howManyChipsScreen(chips); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (input == 00) { - casinoLobbyScreen(currentPlayer); + casinoLobbyScreen(currentPlayer, casinoScreens, console); getOut = false; } else { System.out.println("Invalid Entry"); diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index 5d1b90a34..6a2d7d765 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -41,9 +41,6 @@ private void startMoakGame(MostOfAKindGame moak, Player player, Console console) } //PLACEHOLDER - private void casinoLobby(MostOfAKindGame moak, Player player, Console console) { - casino.casinoLobbyScreen(player); - } private void welcomeInvalidScreen(MostOfAKindGame moak, Player player, Console console) { mScreens.welcomeInvalidMoakScreen(); From 656f7f6fb8b659fda70ba15da77355ce3ec58c4e Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Fri, 19 Mar 2021 00:05:57 -0400 Subject: [PATCH 69/73] final final final final final push --- src/main/java/io/zipcoder/casino/AsciiArt.java | 9 --------- src/main/java/io/zipcoder/casino/CardFactory.java | 8 -------- src/main/java/io/zipcoder/casino/Casino.java | 2 -- src/main/java/io/zipcoder/casino/GoFishEngine.java | 9 --------- src/main/java/io/zipcoder/casino/Main.java | 7 +++++-- src/main/java/io/zipcoder/casino/MostOfAKindGame.java | 4 ---- .../java/io/zipcoder/casino/GoFishTest.java | 0 7 files changed, 5 insertions(+), 34 deletions(-) delete mode 100644 src/main/java/io/zipcoder/casino/AsciiArt.java delete mode 100644 src/main/java/io/zipcoder/casino/CardFactory.java delete mode 100644 src/main/java/io/zipcoder/casino/GoFishEngine.java rename src/{main => test}/java/io/zipcoder/casino/GoFishTest.java (100%) diff --git a/src/main/java/io/zipcoder/casino/AsciiArt.java b/src/main/java/io/zipcoder/casino/AsciiArt.java deleted file mode 100644 index 32a7827fe..000000000 --- a/src/main/java/io/zipcoder/casino/AsciiArt.java +++ /dev/null @@ -1,9 +0,0 @@ -package io.zipcoder.casino; - -import java.awt.*; -import java.awt.image.BufferedImage; - -public class AsciiArt { - - -} diff --git a/src/main/java/io/zipcoder/casino/CardFactory.java b/src/main/java/io/zipcoder/casino/CardFactory.java deleted file mode 100644 index be433d146..000000000 --- a/src/main/java/io/zipcoder/casino/CardFactory.java +++ /dev/null @@ -1,8 +0,0 @@ -package io.zipcoder.casino; - -public class CardFactory { - -// public static Card(String nameOfCard, String suitOfCard, int value) { -// return new Card(nameOfCard, suitOfCard, value); -// } -} diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 2fc8d75ae..55a48067c 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -85,7 +85,6 @@ public void invalidEntryWelcomeScreen(DisplayMainCasinoScreens casinoScreens) { public void goodbyeCasinoScreen(DisplayMainCasinoScreens casinoScreens) { casinoScreens.goodbyeCasinoScreen(); - System.exit(0); } public void casinoLobbyScreen(Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { @@ -181,7 +180,6 @@ public void chipBalanceScreen(int chips, Player currentPlayer, DisplayMainCasino while (getOut) { Integer input = console.getIntegerInput(""); if (input == 00) { - casinoLobbyScreen(currentPlayer, casinoScreens, console); getOut = false; } else { System.out.println("Invalid Entry"); diff --git a/src/main/java/io/zipcoder/casino/GoFishEngine.java b/src/main/java/io/zipcoder/casino/GoFishEngine.java deleted file mode 100644 index 9f64de003..000000000 --- a/src/main/java/io/zipcoder/casino/GoFishEngine.java +++ /dev/null @@ -1,9 +0,0 @@ -package io.zipcoder.casino; - -public class GoFishEngine { - public static void main(String[] args) { - Player dummy=new Player("Arg",1000); - GoFish demo=new GoFish(dummy); - demo.playGame(); - } -} diff --git a/src/main/java/io/zipcoder/casino/Main.java b/src/main/java/io/zipcoder/casino/Main.java index 70e37beb9..3dec9dbb4 100644 --- a/src/main/java/io/zipcoder/casino/Main.java +++ b/src/main/java/io/zipcoder/casino/Main.java @@ -2,8 +2,11 @@ public class Main { - public void main (String[] args) { + public static void main (String[] args) { Casino casino = new Casino(); - casino.run(); + PlayerWarehouse.initializePlayers(); + while (true) { + casino.run(); + } } } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java index 3c2f53adb..fc26ecf2a 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindGame.java @@ -1,10 +1,6 @@ package io.zipcoder.casino; -import io.zipcoder.casino.DiceGame; - -import java.lang.reflect.Array; import java.util.ArrayList; -import java.util.Collection; public class MostOfAKindGame extends DiceGame { ArrayList dealerHand = new ArrayList(); diff --git a/src/main/java/io/zipcoder/casino/GoFishTest.java b/src/test/java/io/zipcoder/casino/GoFishTest.java similarity index 100% rename from src/main/java/io/zipcoder/casino/GoFishTest.java rename to src/test/java/io/zipcoder/casino/GoFishTest.java From 3f2bb9a5aa0cce97a0dfb1e6eb030ea2fe037e8b Mon Sep 17 00:00:00 2001 From: xyuan04 <78838190+xyuan04@users.noreply.github.com> Date: Fri, 19 Mar 2021 00:59:39 -0400 Subject: [PATCH 70/73] minor fixes --- src/main/java/io/zipcoder/casino/BlackJack.java | 7 ++++++- src/main/java/io/zipcoder/casino/CrapsEngine.java | 1 - src/main/java/io/zipcoder/casino/GamblingGame.java | 2 +- .../java/io/zipcoder/casino/BlackJackTest.java | 14 ++++++++++++++ 4 files changed, 21 insertions(+), 3 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/BlackJack.java index 698662811..a5b24c156 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/BlackJack.java @@ -3,7 +3,7 @@ import java.util.ArrayList; import java.util.List; -public class BlackJack extends CardGame { +public class BlackJack extends CardGame implements GamblingGame{ Player currentPlayer; public List playerHand = new ArrayList<>(); public List dealerHand = new ArrayList<>(); @@ -154,4 +154,9 @@ public boolean dealerBust() { return dealerTotal > 21; } + + @Override + public int getPot() { + return sizeOfPot; + } } diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index f777fbaf7..f7ae86de5 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -1,6 +1,5 @@ package io.zipcoder.casino; -import com.sun.tools.javac.util.Assert; import io.zipcoder.casino.utilities.Console; public class CrapsEngine { diff --git a/src/main/java/io/zipcoder/casino/GamblingGame.java b/src/main/java/io/zipcoder/casino/GamblingGame.java index 59cdef6aa..64d612fe8 100644 --- a/src/main/java/io/zipcoder/casino/GamblingGame.java +++ b/src/main/java/io/zipcoder/casino/GamblingGame.java @@ -2,6 +2,6 @@ public interface GamblingGame { - void addToPot(); + void addToPot(int amount); int getPot(); } diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 986e95406..2eec07e82 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -1,5 +1,6 @@ package io.zipcoder.casino; +import org.junit.Assert; import org.junit.Test; import static org.junit.Assert.*; @@ -663,4 +664,17 @@ public void checkWinnerTieTest() { //Then: assertEquals(expected, actual); } + + @Test + public void checkGetPot() { + //Given: + bj.sizeOfPot = 500; + + //When: + int expected = 500; + int actual = bj.getPot(); + + //Then: + assertEquals(expected, actual); + } } \ No newline at end of file From 36cd1e716115813fbc315dd9f3037cf7e65d7f71 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Fri, 19 Mar 2021 08:50:42 -0400 Subject: [PATCH 71/73] setting status --- src/main/java/io/zipcoder/casino/Craps.java | 2 +- .../java/io/zipcoder/casino/CrapsTest.java | 42 ++++++++++++++++++- .../io/zipcoder/casino/MostOfAKindTests.java | 13 ++++++ 3 files changed, 55 insertions(+), 2 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java index aa2ef16e9..f1d69cd9d 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -115,7 +115,7 @@ public int getPointer() { public void setBetStatus(String status) { betStatus.replace(0, betStatus.length(), ""); - betStatus.append(status); + betStatus.append(status.toUpperCase()); } public String getBetStatus() { diff --git a/src/test/java/io/zipcoder/casino/CrapsTest.java b/src/test/java/io/zipcoder/casino/CrapsTest.java index 35f6d622e..4d080231e 100644 --- a/src/test/java/io/zipcoder/casino/CrapsTest.java +++ b/src/test/java/io/zipcoder/casino/CrapsTest.java @@ -33,6 +33,20 @@ public void addToPot() { Assert.assertEquals(expected, actual); } + @Test + public void playerBalanceAfterBet() { + //Given + gerg.setChipBalance(50); + int expected = 40; + + //When + craps.addToPot(10); + int actual = gerg.getChipBalance(); + + //Then + Assert.assertEquals(expected, actual); + } + @Test public void clearPot() { //Given @@ -89,7 +103,7 @@ public void setGetPointer() { @Test public void setGetBetStatus() { //Given - String expected = "Pass"; + String expected = "PASS"; //When craps.setBetStatus("Pass"); @@ -99,6 +113,19 @@ public void setGetBetStatus() { Assert.assertEquals(expected, actual); } + @Test + public void betStatusTwo() { + //Given + String expected = "NOT PASS"; + + //When + craps.setBetStatus("NoT paSS"); + String actual = craps.getBetStatus(); + + //Then + Assert.assertEquals(expected, actual); + } + @Test public void sumOfDice() { //Given @@ -112,6 +139,19 @@ public void sumOfDice() { Assert.assertTrue(actual > 1 && actual < 13); } + @Test + public void getCurrentSum() { + //Given + craps.currentSum = 10; + int expected = 10; + + //When + int actual = craps.getCurrentSum(); + + //Then + Assert.assertEquals(expected, actual); + } + //Round One Pass Outcomes @Test public void playerWinsRoundOnePass() { diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 5b569bd99..5ffd7470a 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -22,6 +22,19 @@ public void getPot() { Assert.assertEquals(expected, actual); } + @Test + public void getPotTwo() { + //Given + yahtzee.addToPot(10); + int expected = 10; + + //When + int actual = yahtzee.getPot(); + + //Then + Assert.assertEquals(expected, actual); + } + @Test public void addToPot() { //Given From 9c12b539712f4eadbc3bd501e6f1f5d70f8c6400 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Fri, 19 Mar 2021 19:23:59 -0400 Subject: [PATCH 72/73] shorter lines --- src/main/java/io/zipcoder/casino/Casino.java | 3 +- src/main/java/io/zipcoder/casino/Craps.java | 3 -- .../java/io/zipcoder/casino/CrapsEngine.java | 8 ---- .../io/zipcoder/casino/MostOfAKindEngine.java | 43 ------------------- 4 files changed, 2 insertions(+), 55 deletions(-) diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 55a48067c..0cb1cfb2c 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -20,6 +20,7 @@ public void welcome() { getOut = false; } else if (input == 99) { goodbyeCasinoScreen(casinoScreens); + System.exit(0); getOut = false; } else { invalidEntryWelcomeScreen(casinoScreens); @@ -149,7 +150,6 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer, DisplayMainCasi tellerWindow(currentPlayer, casinoScreens, console); getOut = false; } else if (input == 2) { - casinoLobbyScreen(currentPlayer, casinoScreens, console); getOut = false; } else { System.out.println("Invalid Entry"); @@ -166,6 +166,7 @@ public void tellerMoneyToChipsScreen(Player currentPlayer, DisplayMainCasinoScre if (input <= currentPlayer.getWallet()) { int chips = exchange.moneyToChips(input); currentPlayer.getMoreChips(chips); + currentPlayer.getMoreChips(chips); chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer, casinoScreens, console); getOut = false; } else { diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/Craps.java index f1d69cd9d..6d196e91a 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/Craps.java @@ -23,7 +23,6 @@ public int getPot() { return pot; } - //1: player wins, 2: dealer wins, 3: move to next round public int checkWinnerRoundOne(int sumOfDice) { int outcome = 0; @@ -63,8 +62,6 @@ public int checkWinnerRoundOne(int sumOfDice) { return outcome; } - - //1: player wins, 2: player loses, 3: roll again public int checkWinnerRoundTwo(int sumOfDice) { int outcome; diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/CrapsEngine.java index f7ae86de5..5f8067f44 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/CrapsEngine.java @@ -5,8 +5,6 @@ public class CrapsEngine { CrapsScreens cScreens = new CrapsScreens(); Player player; - //Casino casino = new Casino(); - public CrapsEngine(Player player) { this.player = player; @@ -18,7 +16,6 @@ public void craps() { startCrapsGame(craps, player, console); } - public void startCrapsGame(Craps craps, Player player, Console console) { cScreens.crapsWelcomeScreen(); System.out.println(player.getPlayerName()); @@ -41,11 +38,6 @@ public void crapsInvalidWelcomeScreen(Craps craps, Player player, Console consol cScreens.crapsInvalidWelcomeScreen(); } - -// public void casinoLobby(Player player) { -// casino.casinoLobbyScreen(player); -// } - public void passOrNotPassRoundOneScreen(int gameRound, Craps craps, Player player, Console console) { craps.setGameRound(1); craps.clearPot(); diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java index 6a2d7d765..106ce9dab 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java @@ -6,7 +6,6 @@ public class MostOfAKindEngine { Player player; - Casino casino = new Casino(); MostOfAKindScreens mScreens = new MostOfAKindScreens(); public MostOfAKindEngine(Player player) { @@ -40,8 +39,6 @@ private void startMoakGame(MostOfAKindGame moak, Player player, Console console) } } - //PLACEHOLDER - private void welcomeInvalidScreen(MostOfAKindGame moak, Player player, Console console) { mScreens.welcomeInvalidMoakScreen(); } @@ -72,19 +69,6 @@ private void anteUpScreen(MostOfAKindGame moak, Player player, Console console) } } -// private void needMoreChipsScreen(MostOfAKindGame moak, Player player, Console console) { -// mScreens.needMoreChipsScreen(); -// boolean getOut = true; -// while (getOut) { -// Integer input = console.getIntegerInput(""); -// if (input == 0) { -// getOut = false; -// } else { -// System.out.println("Invalid Entry"); -// } -// } -// } - private void firstRollScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.firstRollScreen(pot, playerHand); boolean getOut = true; @@ -100,21 +84,6 @@ private void firstRollScreen(int pot, ArrayList playerHand, MostOfAKind } } -// private void getMoreChips(MostOfAKindGame moak, Player player, Console console) { -// mScreens.getMoreChips(); -// boolean getOut = true; -// while (getOut) { -// Integer input = console.getIntegerInput(""); -// if (input == 0) { -// getOut = false; -// } else if (input == 1) { -// firstRollScreen(moak.getPot(), moak.getPlayerHand(), moak, player, console); -// } else { -// System.out.println("Invalid Entry"); -// } -// } -// } - private void numberToKeepScreen(int pot, ArrayList playerHand, MostOfAKindGame moak, Player player, Console console) { mScreens.numberToKeepScreen(pot, playerHand); boolean getOut = true; @@ -195,16 +164,4 @@ private void revealHandsPlayerWins(int pot, ArrayList playerHand, Array } } } - -// private void goodbyeScreen(MostOfAKindGame moak, Player player, Console console) { -// mScreens.goodbyeScreen(); -// while (getOut) { -// Integer input = console.getIntegerInput(""); -// if (input == 0) { -// getOut = false; -// } else { -// System.out.println("Invalid Entry"); -// } -// } -// } } From 78ceb3f348706c0a7014b0031b64aea499f3b9e4 Mon Sep 17 00:00:00 2001 From: Greg Donnelly Date: Fri, 19 Mar 2021 19:46:05 -0400 Subject: [PATCH 73/73] Gerg FINALE --- .../casino/{ => CardGames}/BlackJack.java | 7 ++-- .../{ => CardGames}/BlackJackEngine.java | 3 +- .../zipcoder/casino/{ => CardGames}/Card.java | 2 +- .../casino/{ => CardGames}/CardGame.java | 4 ++- .../casino/{ => CardGames}/GoFish.java | 4 +-- src/main/java/io/zipcoder/casino/Casino.java | 20 ++++++----- .../io/zipcoder/casino/ChipMoneyExchange.java | 14 -------- .../casino/{ => DiceGames}/Craps.java | 20 ++++++----- .../casino/{ => DiceGames}/CrapsEngine.java | 4 ++- .../casino/{ => DiceGames}/DiceGame.java | 8 +++-- .../{ => DiceGames}/MostOfAKindEngine.java | 4 ++- .../{ => DiceGames}/MostOfAKindGame.java | 16 +++++---- .../java/io/zipcoder/casino/Displays.java | 30 ----------------- .../java/io/zipcoder/casino/GamblingGame.java | 1 - .../io/zipcoder/casino/GamblingPlayer.java | 1 - src/main/java/io/zipcoder/casino/Game.java | 6 ++-- src/main/java/io/zipcoder/casino/Main.java | 2 ++ .../zipcoder/casino/{ => Player}/Player.java | 6 ++-- .../casino/{ => Player}/PlayerFactory.java | 2 +- .../casino/{ => Player}/PlayerWarehouse.java | 2 +- .../casino/{ => Screens}/CrapsScreens.java | 2 +- .../DisplayMainCasinoScreens.java | 2 +- .../io/zipcoder/casino/Screens/Displays.java | 13 ++++++++ .../{ => Screens}/MostOfAKindScreens.java | 2 +- .../io/zipcoder/casino/BlackJackTest.java | 5 ++- .../java/io/zipcoder/casino/CardTest.java | 1 + .../casino/ChipMoneyExchangeTest.java | 33 ------------------- .../java/io/zipcoder/casino/CrapsTest.java | 4 +++ .../java/io/zipcoder/casino/GoFishTest.java | 2 ++ .../io/zipcoder/casino/MostOfAKindTests.java | 4 ++- .../io/zipcoder/casino/PlayerFactoryTest.java | 4 +-- .../java/io/zipcoder/casino/PlayerTest.java | 3 +- .../zipcoder/casino/PlayerWarehouseTest.java | 5 +-- 33 files changed, 102 insertions(+), 134 deletions(-) rename src/main/java/io/zipcoder/casino/{ => CardGames}/BlackJack.java (96%) rename src/main/java/io/zipcoder/casino/{ => CardGames}/BlackJackEngine.java (99%) rename src/main/java/io/zipcoder/casino/{ => CardGames}/Card.java (95%) rename src/main/java/io/zipcoder/casino/{ => CardGames}/CardGame.java (98%) rename src/main/java/io/zipcoder/casino/{ => CardGames}/GoFish.java (99%) delete mode 100644 src/main/java/io/zipcoder/casino/ChipMoneyExchange.java rename src/main/java/io/zipcoder/casino/{ => DiceGames}/Craps.java (87%) rename src/main/java/io/zipcoder/casino/{ => DiceGames}/CrapsEngine.java (98%) rename src/main/java/io/zipcoder/casino/{ => DiceGames}/DiceGame.java (70%) rename src/main/java/io/zipcoder/casino/{ => DiceGames}/MostOfAKindEngine.java (98%) rename src/main/java/io/zipcoder/casino/{ => DiceGames}/MostOfAKindGame.java (94%) delete mode 100644 src/main/java/io/zipcoder/casino/Displays.java rename src/main/java/io/zipcoder/casino/{ => Player}/Player.java (92%) rename src/main/java/io/zipcoder/casino/{ => Player}/PlayerFactory.java (80%) rename src/main/java/io/zipcoder/casino/{ => Player}/PlayerWarehouse.java (96%) rename src/main/java/io/zipcoder/casino/{ => Screens}/CrapsScreens.java (99%) rename src/main/java/io/zipcoder/casino/{ => Screens}/DisplayMainCasinoScreens.java (99%) create mode 100644 src/main/java/io/zipcoder/casino/Screens/Displays.java rename src/main/java/io/zipcoder/casino/{ => Screens}/MostOfAKindScreens.java (99%) delete mode 100644 src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java diff --git a/src/main/java/io/zipcoder/casino/BlackJack.java b/src/main/java/io/zipcoder/casino/CardGames/BlackJack.java similarity index 96% rename from src/main/java/io/zipcoder/casino/BlackJack.java rename to src/main/java/io/zipcoder/casino/CardGames/BlackJack.java index a5b24c156..5157991e1 100644 --- a/src/main/java/io/zipcoder/casino/BlackJack.java +++ b/src/main/java/io/zipcoder/casino/CardGames/BlackJack.java @@ -1,9 +1,12 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.CardGames; + +import io.zipcoder.casino.GamblingGame; +import io.zipcoder.casino.Player.Player; import java.util.ArrayList; import java.util.List; -public class BlackJack extends CardGame implements GamblingGame{ +public class BlackJack extends CardGame implements GamblingGame { Player currentPlayer; public List playerHand = new ArrayList<>(); public List dealerHand = new ArrayList<>(); diff --git a/src/main/java/io/zipcoder/casino/BlackJackEngine.java b/src/main/java/io/zipcoder/casino/CardGames/BlackJackEngine.java similarity index 99% rename from src/main/java/io/zipcoder/casino/BlackJackEngine.java rename to src/main/java/io/zipcoder/casino/CardGames/BlackJackEngine.java index 6fe72cefd..382a99e79 100644 --- a/src/main/java/io/zipcoder/casino/BlackJackEngine.java +++ b/src/main/java/io/zipcoder/casino/CardGames/BlackJackEngine.java @@ -1,5 +1,6 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.CardGames; +import io.zipcoder.casino.Player.Player; import io.zipcoder.casino.utilities.Console; public class BlackJackEngine { diff --git a/src/main/java/io/zipcoder/casino/Card.java b/src/main/java/io/zipcoder/casino/CardGames/Card.java similarity index 95% rename from src/main/java/io/zipcoder/casino/Card.java rename to src/main/java/io/zipcoder/casino/CardGames/Card.java index deaa6f778..15aa90367 100644 --- a/src/main/java/io/zipcoder/casino/Card.java +++ b/src/main/java/io/zipcoder/casino/CardGames/Card.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.CardGames; public class Card { //value from ace to king diff --git a/src/main/java/io/zipcoder/casino/CardGame.java b/src/main/java/io/zipcoder/casino/CardGames/CardGame.java similarity index 98% rename from src/main/java/io/zipcoder/casino/CardGame.java rename to src/main/java/io/zipcoder/casino/CardGames/CardGame.java index 92e562dee..4f4c74667 100644 --- a/src/main/java/io/zipcoder/casino/CardGame.java +++ b/src/main/java/io/zipcoder/casino/CardGames/CardGame.java @@ -1,4 +1,6 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.CardGames; + +import io.zipcoder.casino.Game; import java.util.ArrayList; import java.util.Collections; diff --git a/src/main/java/io/zipcoder/casino/GoFish.java b/src/main/java/io/zipcoder/casino/CardGames/GoFish.java similarity index 99% rename from src/main/java/io/zipcoder/casino/GoFish.java rename to src/main/java/io/zipcoder/casino/CardGames/GoFish.java index 2212f8472..1478ca098 100644 --- a/src/main/java/io/zipcoder/casino/GoFish.java +++ b/src/main/java/io/zipcoder/casino/CardGames/GoFish.java @@ -1,10 +1,10 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.CardGames; +import io.zipcoder.casino.Player.Player; import io.zipcoder.casino.utilities.Console; import java.util.ArrayList; import java.util.List; -import java.util.Locale; import java.util.Random; public class GoFish extends CardGame { diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java index 0cb1cfb2c..d98c8331c 100644 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ b/src/main/java/io/zipcoder/casino/Casino.java @@ -1,5 +1,12 @@ package io.zipcoder.casino; - +import io.zipcoder.casino.CardGames.BlackJackEngine; +import io.zipcoder.casino.CardGames.GoFish; +import io.zipcoder.casino.DiceGames.CrapsEngine; +import io.zipcoder.casino.DiceGames.MostOfAKindEngine; +import io.zipcoder.casino.Player.Player; +import io.zipcoder.casino.Player.PlayerFactory; +import io.zipcoder.casino.Player.PlayerWarehouse; +import io.zipcoder.casino.Screens.DisplayMainCasinoScreens; import io.zipcoder.casino.utilities.Console; public class Casino { @@ -129,7 +136,7 @@ public void tellerWindow(Player currentPlayer, DisplayMainCasinoScreens casinoSc getOut = false; } else if (input == 2) { cashOutChips(currentPlayer.getChipBalance(), currentPlayer, casinoScreens, console); - currentPlayer.setChipBalance(0); + currentPlayer.cashOut(); getOut = false; } else { tellerInvalidMainScreen(casinoScreens); @@ -158,16 +165,13 @@ public void cashOutChips(int chipsCashOut, Player currentPlayer, DisplayMainCasi } public void tellerMoneyToChipsScreen(Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { - ChipMoneyExchange exchange = new ChipMoneyExchange(); casinoScreens.tellerMoneyToChipsScreen(currentPlayer.getChipBalance(), currentPlayer.getWallet()); boolean getOut = true; while (getOut) { Integer input = console.getIntegerInput(""); if (input <= currentPlayer.getWallet()) { - int chips = exchange.moneyToChips(input); - currentPlayer.getMoreChips(chips); - currentPlayer.getMoreChips(chips); - chipBalanceScreen(currentPlayer.getChipBalance(), currentPlayer, casinoScreens, console); + currentPlayer.getMoreChips(input); + chipBalanceScreen(currentPlayer.getChipBalance(), casinoScreens, console); getOut = false; } else { System.out.println("Not enough cash"); @@ -175,7 +179,7 @@ public void tellerMoneyToChipsScreen(Player currentPlayer, DisplayMainCasinoScre } } - public void chipBalanceScreen(int chips, Player currentPlayer, DisplayMainCasinoScreens casinoScreens, Console console) { + public void chipBalanceScreen(int chips, DisplayMainCasinoScreens casinoScreens, Console console) { casinoScreens.howManyChipsScreen(chips); boolean getOut = true; while (getOut) { diff --git a/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java b/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java deleted file mode 100644 index 38ab5e106..000000000 --- a/src/main/java/io/zipcoder/casino/ChipMoneyExchange.java +++ /dev/null @@ -1,14 +0,0 @@ -package io.zipcoder.casino; - -public class ChipMoneyExchange { - Player player; - - - public int moneyToChips(int cash) { - return cash; - } - - public int chipsToMoney(int numOfChips) { - return numOfChips; - } -} diff --git a/src/main/java/io/zipcoder/casino/Craps.java b/src/main/java/io/zipcoder/casino/DiceGames/Craps.java similarity index 87% rename from src/main/java/io/zipcoder/casino/Craps.java rename to src/main/java/io/zipcoder/casino/DiceGames/Craps.java index 6d196e91a..deaa24843 100644 --- a/src/main/java/io/zipcoder/casino/Craps.java +++ b/src/main/java/io/zipcoder/casino/DiceGames/Craps.java @@ -1,14 +1,16 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.DiceGames; + +import io.zipcoder.casino.Player.Player; public class Craps extends DiceGame { - int gameRound = 1; - StringBuffer betStatus = new StringBuffer("hi"); - Player currentPlayer; - Integer[] roundOnePass = new Integer[]{7, 11}; - Integer[] roundOneNotPass = new Integer[]{2, 3, 12}; - Integer[] rollAgain = new Integer[]{4, 5, 6, 8, 9, 10}; - int pointer; - int currentSum; + public int gameRound = 1; + public StringBuffer betStatus = new StringBuffer("hi"); + public Player currentPlayer; + public Integer[] roundOnePass = new Integer[]{7, 11}; + public Integer[] roundOneNotPass = new Integer[]{2, 3, 12}; + public Integer[] rollAgain = new Integer[]{4, 5, 6, 8, 9, 10}; + public int pointer; + public int currentSum; public Craps(Player currentPlayer) { this.currentPlayer = currentPlayer; diff --git a/src/main/java/io/zipcoder/casino/CrapsEngine.java b/src/main/java/io/zipcoder/casino/DiceGames/CrapsEngine.java similarity index 98% rename from src/main/java/io/zipcoder/casino/CrapsEngine.java rename to src/main/java/io/zipcoder/casino/DiceGames/CrapsEngine.java index 5f8067f44..e70380cc0 100644 --- a/src/main/java/io/zipcoder/casino/CrapsEngine.java +++ b/src/main/java/io/zipcoder/casino/DiceGames/CrapsEngine.java @@ -1,5 +1,7 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.DiceGames; +import io.zipcoder.casino.Screens.CrapsScreens; +import io.zipcoder.casino.Player.Player; import io.zipcoder.casino.utilities.Console; public class CrapsEngine { diff --git a/src/main/java/io/zipcoder/casino/DiceGame.java b/src/main/java/io/zipcoder/casino/DiceGames/DiceGame.java similarity index 70% rename from src/main/java/io/zipcoder/casino/DiceGame.java rename to src/main/java/io/zipcoder/casino/DiceGames/DiceGame.java index ba20cff70..b03b871e3 100644 --- a/src/main/java/io/zipcoder/casino/DiceGame.java +++ b/src/main/java/io/zipcoder/casino/DiceGames/DiceGame.java @@ -1,11 +1,13 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.DiceGames; + +import io.zipcoder.casino.GamblingGame; import java.util.ArrayList; public abstract class DiceGame implements GamblingGame { private int totalNumOfDice; - ArrayList playerDiceHand = new ArrayList(); - int pot = 0; + public ArrayList playerDiceHand = new ArrayList(); + public int pot = 0; public void addToPot() { } diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java b/src/main/java/io/zipcoder/casino/DiceGames/MostOfAKindEngine.java similarity index 98% rename from src/main/java/io/zipcoder/casino/MostOfAKindEngine.java rename to src/main/java/io/zipcoder/casino/DiceGames/MostOfAKindEngine.java index 106ce9dab..05dee2d0e 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindEngine.java +++ b/src/main/java/io/zipcoder/casino/DiceGames/MostOfAKindEngine.java @@ -1,5 +1,7 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.DiceGames; +import io.zipcoder.casino.Screens.MostOfAKindScreens; +import io.zipcoder.casino.Player.Player; import io.zipcoder.casino.utilities.Console; import java.util.ArrayList; diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java b/src/main/java/io/zipcoder/casino/DiceGames/MostOfAKindGame.java similarity index 94% rename from src/main/java/io/zipcoder/casino/MostOfAKindGame.java rename to src/main/java/io/zipcoder/casino/DiceGames/MostOfAKindGame.java index fc26ecf2a..76bb83f36 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindGame.java +++ b/src/main/java/io/zipcoder/casino/DiceGames/MostOfAKindGame.java @@ -1,14 +1,16 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.DiceGames; + +import io.zipcoder.casino.Player.Player; import java.util.ArrayList; public class MostOfAKindGame extends DiceGame { - ArrayList dealerHand = new ArrayList(); - int playerMatchingNum; - int dealerMatchingNum; - int dealerCount; - int playerCount; - Player currentPlayer; + public ArrayList dealerHand = new ArrayList(); + public int playerMatchingNum; + public int dealerMatchingNum; + public int dealerCount; + public int playerCount; + public Player currentPlayer; public MostOfAKindGame(Player player) { this.currentPlayer = player; diff --git a/src/main/java/io/zipcoder/casino/Displays.java b/src/main/java/io/zipcoder/casino/Displays.java deleted file mode 100644 index b59ac9b50..000000000 --- a/src/main/java/io/zipcoder/casino/Displays.java +++ /dev/null @@ -1,30 +0,0 @@ -package io.zipcoder.casino; - -import java.util.Scanner; - -public class Displays { - - public static String getStringInput() { - Scanner scanner = new Scanner(System.in); - String userInput = scanner.nextLine(); - return userInput; - } - - public static void print(String output, Object... args) { - System.out.printf(output, args); - } - - public static void println(String output, Object... args) { - print(output + "\n", args); - } - - public void notEnoughMoneyScreen() { - println(" "); - println("You don't have enough chips"); - println(" "); - println(" 00: Return and try again "); - println(" "); - - } - -} diff --git a/src/main/java/io/zipcoder/casino/GamblingGame.java b/src/main/java/io/zipcoder/casino/GamblingGame.java index 64d612fe8..10b4745e8 100644 --- a/src/main/java/io/zipcoder/casino/GamblingGame.java +++ b/src/main/java/io/zipcoder/casino/GamblingGame.java @@ -1,7 +1,6 @@ package io.zipcoder.casino; public interface GamblingGame { - void addToPot(int amount); int getPot(); } diff --git a/src/main/java/io/zipcoder/casino/GamblingPlayer.java b/src/main/java/io/zipcoder/casino/GamblingPlayer.java index b7d7d17c6..c0faecc77 100644 --- a/src/main/java/io/zipcoder/casino/GamblingPlayer.java +++ b/src/main/java/io/zipcoder/casino/GamblingPlayer.java @@ -1,7 +1,6 @@ package io.zipcoder.casino; public interface GamblingPlayer { - void wageMoney(int wageAmount); void cashOut(); void getMoreChips(int buyAmount); diff --git a/src/main/java/io/zipcoder/casino/Game.java b/src/main/java/io/zipcoder/casino/Game.java index 87c142a69..175051246 100644 --- a/src/main/java/io/zipcoder/casino/Game.java +++ b/src/main/java/io/zipcoder/casino/Game.java @@ -1,8 +1,6 @@ package io.zipcoder.casino; public interface Game { - public void playGame(); - - - public String checkWinner(); + void playGame(); + String checkWinner(); } diff --git a/src/main/java/io/zipcoder/casino/Main.java b/src/main/java/io/zipcoder/casino/Main.java index 3dec9dbb4..ee911d066 100644 --- a/src/main/java/io/zipcoder/casino/Main.java +++ b/src/main/java/io/zipcoder/casino/Main.java @@ -1,5 +1,7 @@ package io.zipcoder.casino; +import io.zipcoder.casino.Player.PlayerWarehouse; + public class Main { public static void main (String[] args) { diff --git a/src/main/java/io/zipcoder/casino/Player.java b/src/main/java/io/zipcoder/casino/Player/Player.java similarity index 92% rename from src/main/java/io/zipcoder/casino/Player.java rename to src/main/java/io/zipcoder/casino/Player/Player.java index 6c7a5277a..801066b71 100644 --- a/src/main/java/io/zipcoder/casino/Player.java +++ b/src/main/java/io/zipcoder/casino/Player/Player.java @@ -1,6 +1,8 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.Player; -public class Player implements GamblingPlayer{ +import io.zipcoder.casino.GamblingPlayer; + +public class Player implements GamblingPlayer { private String playerName; private final int playerID; private int wallet; diff --git a/src/main/java/io/zipcoder/casino/PlayerFactory.java b/src/main/java/io/zipcoder/casino/Player/PlayerFactory.java similarity index 80% rename from src/main/java/io/zipcoder/casino/PlayerFactory.java rename to src/main/java/io/zipcoder/casino/Player/PlayerFactory.java index 36a663f3c..3c4c77bb4 100644 --- a/src/main/java/io/zipcoder/casino/PlayerFactory.java +++ b/src/main/java/io/zipcoder/casino/Player/PlayerFactory.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.Player; public class PlayerFactory { diff --git a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java b/src/main/java/io/zipcoder/casino/Player/PlayerWarehouse.java similarity index 96% rename from src/main/java/io/zipcoder/casino/PlayerWarehouse.java rename to src/main/java/io/zipcoder/casino/Player/PlayerWarehouse.java index e7f15c8e7..82ae94028 100644 --- a/src/main/java/io/zipcoder/casino/PlayerWarehouse.java +++ b/src/main/java/io/zipcoder/casino/Player/PlayerWarehouse.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.Player; import java.util.HashMap; import java.util.Map; diff --git a/src/main/java/io/zipcoder/casino/CrapsScreens.java b/src/main/java/io/zipcoder/casino/Screens/CrapsScreens.java similarity index 99% rename from src/main/java/io/zipcoder/casino/CrapsScreens.java rename to src/main/java/io/zipcoder/casino/Screens/CrapsScreens.java index 8da466b93..f9eaa135f 100644 --- a/src/main/java/io/zipcoder/casino/CrapsScreens.java +++ b/src/main/java/io/zipcoder/casino/Screens/CrapsScreens.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.Screens; public class CrapsScreens extends Displays { //WELCOME diff --git a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java b/src/main/java/io/zipcoder/casino/Screens/DisplayMainCasinoScreens.java similarity index 99% rename from src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java rename to src/main/java/io/zipcoder/casino/Screens/DisplayMainCasinoScreens.java index de4127453..858d58046 100644 --- a/src/main/java/io/zipcoder/casino/DisplayMainCasinoScreens.java +++ b/src/main/java/io/zipcoder/casino/Screens/DisplayMainCasinoScreens.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.Screens; public class DisplayMainCasinoScreens extends Displays{ diff --git a/src/main/java/io/zipcoder/casino/Screens/Displays.java b/src/main/java/io/zipcoder/casino/Screens/Displays.java new file mode 100644 index 000000000..55ce6b96f --- /dev/null +++ b/src/main/java/io/zipcoder/casino/Screens/Displays.java @@ -0,0 +1,13 @@ +package io.zipcoder.casino.Screens; + +public class Displays { + + public static void print(String output, Object... args) { + System.out.printf(output, args); + } + + public static void println(String output, Object... args) { + print(output + "\n", args); + } + +} diff --git a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java b/src/main/java/io/zipcoder/casino/Screens/MostOfAKindScreens.java similarity index 99% rename from src/main/java/io/zipcoder/casino/MostOfAKindScreens.java rename to src/main/java/io/zipcoder/casino/Screens/MostOfAKindScreens.java index 46969826e..deff2a8b1 100644 --- a/src/main/java/io/zipcoder/casino/MostOfAKindScreens.java +++ b/src/main/java/io/zipcoder/casino/Screens/MostOfAKindScreens.java @@ -1,4 +1,4 @@ -package io.zipcoder.casino; +package io.zipcoder.casino.Screens; import java.util.ArrayList; diff --git a/src/test/java/io/zipcoder/casino/BlackJackTest.java b/src/test/java/io/zipcoder/casino/BlackJackTest.java index 2eec07e82..084471fe6 100644 --- a/src/test/java/io/zipcoder/casino/BlackJackTest.java +++ b/src/test/java/io/zipcoder/casino/BlackJackTest.java @@ -1,6 +1,9 @@ package io.zipcoder.casino; -import org.junit.Assert; +import io.zipcoder.casino.CardGames.BlackJack; +import io.zipcoder.casino.CardGames.Card; +import io.zipcoder.casino.Player.Player; +import io.zipcoder.casino.Player.PlayerFactory; import org.junit.Test; import static org.junit.Assert.*; diff --git a/src/test/java/io/zipcoder/casino/CardTest.java b/src/test/java/io/zipcoder/casino/CardTest.java index 49dce6b5f..f26ab3cf5 100644 --- a/src/test/java/io/zipcoder/casino/CardTest.java +++ b/src/test/java/io/zipcoder/casino/CardTest.java @@ -1,5 +1,6 @@ package io.zipcoder.casino; +import io.zipcoder.casino.CardGames.Card; import org.junit.Assert; import org.junit.Test; diff --git a/src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java b/src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java deleted file mode 100644 index 7d99df8bd..000000000 --- a/src/test/java/io/zipcoder/casino/ChipMoneyExchangeTest.java +++ /dev/null @@ -1,33 +0,0 @@ -package io.zipcoder.casino; - -import org.junit.Assert; -import org.junit.Test; - -public class ChipMoneyExchangeTest { - - @Test - public void chipsToMoney() { - //Given - ChipMoneyExchange exchange = new ChipMoneyExchange(); - int expected = 10; - - //When - int actual = exchange.chipsToMoney(10); - - //Then - Assert.assertEquals(expected, actual); - } - - @Test - public void moneyToChips() { - //Given - ChipMoneyExchange exchange = new ChipMoneyExchange(); - int expected = 12; - - //When - int actual = exchange.moneyToChips(12); - - //Then - Assert.assertEquals(expected, actual); - } -} diff --git a/src/test/java/io/zipcoder/casino/CrapsTest.java b/src/test/java/io/zipcoder/casino/CrapsTest.java index 4d080231e..440ba662a 100644 --- a/src/test/java/io/zipcoder/casino/CrapsTest.java +++ b/src/test/java/io/zipcoder/casino/CrapsTest.java @@ -1,8 +1,12 @@ package io.zipcoder.casino; +import io.zipcoder.casino.DiceGames.Craps; +import io.zipcoder.casino.Player.Player; +import io.zipcoder.casino.Player.PlayerFactory; import org.junit.Assert; import org.junit.Test; + public class CrapsTest { Player gerg = PlayerFactory.createPlayer("gerg", 500); Craps craps = new Craps(gerg); diff --git a/src/test/java/io/zipcoder/casino/GoFishTest.java b/src/test/java/io/zipcoder/casino/GoFishTest.java index 22320a20e..e77b433eb 100644 --- a/src/test/java/io/zipcoder/casino/GoFishTest.java +++ b/src/test/java/io/zipcoder/casino/GoFishTest.java @@ -1,6 +1,8 @@ package io.zipcoder.casino; +import io.zipcoder.casino.CardGames.Card; +import io.zipcoder.casino.CardGames.GoFish; import org.junit.Assert; import org.junit.jupiter.api.Test; diff --git a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java index 5ffd7470a..1fb785d86 100644 --- a/src/test/java/io/zipcoder/casino/MostOfAKindTests.java +++ b/src/test/java/io/zipcoder/casino/MostOfAKindTests.java @@ -1,9 +1,11 @@ package io.zipcoder.casino; +import io.zipcoder.casino.DiceGames.MostOfAKindGame; +import io.zipcoder.casino.Player.Player; +import io.zipcoder.casino.Player.PlayerFactory; import org.junit.Assert; import org.junit.Test; -import java.lang.reflect.Array; import java.util.ArrayList; public class MostOfAKindTests { diff --git a/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java b/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java index 8caacf23a..d8ab1839d 100644 --- a/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java +++ b/src/test/java/io/zipcoder/casino/PlayerFactoryTest.java @@ -1,10 +1,10 @@ package io.zipcoder.casino; +import io.zipcoder.casino.Player.Player; +import io.zipcoder.casino.Player.PlayerFactory; import org.junit.Assert; import org.junit.Test; -import static org.junit.Assert.*; - public class PlayerFactoryTest { @Test diff --git a/src/test/java/io/zipcoder/casino/PlayerTest.java b/src/test/java/io/zipcoder/casino/PlayerTest.java index 59c83ce67..e944d1826 100644 --- a/src/test/java/io/zipcoder/casino/PlayerTest.java +++ b/src/test/java/io/zipcoder/casino/PlayerTest.java @@ -1,10 +1,9 @@ package io.zipcoder.casino; +import io.zipcoder.casino.Player.Player; import org.junit.Assert; import org.junit.Test; -import static org.junit.Assert.*; - public class PlayerTest { String name = "Gerg"; int stash = 5000; diff --git a/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java index 68d67797b..d24c83c5f 100644 --- a/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java +++ b/src/test/java/io/zipcoder/casino/PlayerWarehouseTest.java @@ -1,10 +1,11 @@ package io.zipcoder.casino; +import io.zipcoder.casino.Player.Player; +import io.zipcoder.casino.Player.PlayerFactory; +import io.zipcoder.casino.Player.PlayerWarehouse; import org.junit.Assert; import org.junit.Test; -import static org.junit.Assert.*; - public class PlayerWarehouseTest { @Test