diff --git a/pom.xml b/pom.xml index c6ec0cc8b..96315aca4 100644 --- a/pom.xml +++ b/pom.xml @@ -7,7 +7,18 @@ io.zipcoder casino 1.0-SNAPSHOT - + + + + org.apache.maven.plugins + maven-compiler-plugin + + 8 + 8 + + + + junit diff --git a/src/main/java/Act.java b/src/main/java/Act.java new file mode 100644 index 000000000..f88abea6d --- /dev/null +++ b/src/main/java/Act.java @@ -0,0 +1,25 @@ +public enum Act { + + QUIT("leave", "end", "quit", "q", "leave game", "end game"), + PLAY("play game", "games", "game", "play a game", "play games", "gamble"), + BLACKJACK("blackjack", "bj", "2"), + POKER("Texas Hold 'em", "poker", "3"), + PALACE("palace", "1"), + CRAPS("craps", "dolio style craps", "dolio-style craps", "ds craps", "dolio"), + CEELO("cee lo", "cee-lo", "ceelow", "cee-low", "ceelo"), + DRINK("drink", "get a drink", "bar", "water"), + EAT("eat", "get a bite to eat", "food", "restaurant", "grub", "chow", "dinner", "snacks"), + LOUNGE("lounge", "lobby", "restroom", "rest room", "resting room"); + + private String[] inputPossibilities; + + Act(String ...input) { + inputPossibilities = input; + } + + + public String[] getInputPossibilities() { + return inputPossibilities; + } + +} diff --git a/src/main/java/Action.java b/src/main/java/Action.java new file mode 100644 index 000000000..31c0fd4d6 --- /dev/null +++ b/src/main/java/Action.java @@ -0,0 +1,20 @@ +public class Action { + private String input; + + public Action(String input) { + this.input = input; + } + + public String toActionString() { + return ""; + } + + public Act getAct() { + + return Act.QUIT; + } + + public String normalizeInput() { + return ""; + } +} diff --git a/src/main/java/BlackJack.java b/src/main/java/BlackJack.java new file mode 100644 index 000000000..2f188727b --- /dev/null +++ b/src/main/java/BlackJack.java @@ -0,0 +1,38 @@ + +import java.util.ArrayList; + +public class BlackJack extends CardGame { +ArrayList playerHand = new ArrayList<>(5); +ArrayList houseHand = new ArrayList<>(5); + +Integer sumHand = 0; + + + public BlackJack(BlackJack_Player[] players, Integer numberOfDecks) { + super(players, numberOfDecks); + } + + public Boolean canSplit(){ + ArrayList playerHand = new ArrayList<>(5); + if(playerHand.get(0) == playerHand.get(1)){ + return true; + } + return false;} + /*public Boolean checkWin(){ + if () + }*/ + public Integer HandSum(Hand hand){ + for (int i = 0; i < 5; i++) { + if(playerHand.get(i).getValue() != null){ + + sumHand += playerHand.get(i).getValue(); + } + + }return sumHand; + } + public Boolean didWin(Player player) {return false;} + + public void playGame() {} + public void endOfGame() {} + +} diff --git a/src/main/java/BlackJackHand.java b/src/main/java/BlackJackHand.java new file mode 100644 index 000000000..91a958731 --- /dev/null +++ b/src/main/java/BlackJackHand.java @@ -0,0 +1,9 @@ +import java.util.ArrayList; + +public class BlackJackHand extends Hand { + + + public BlackJackHand(ArrayList cards) { + super(cards); + } +} diff --git a/src/main/java/BlackJackTurn.java b/src/main/java/BlackJackTurn.java new file mode 100644 index 000000000..e97dc6284 --- /dev/null +++ b/src/main/java/BlackJackTurn.java @@ -0,0 +1,3 @@ +public class BlackJackTurn extends Turn { + public Boolean validMove() {return false;} +} diff --git a/src/main/java/BlackJack_Player.java b/src/main/java/BlackJack_Player.java new file mode 100644 index 000000000..b6a25eca7 --- /dev/null +++ b/src/main/java/BlackJack_Player.java @@ -0,0 +1,32 @@ +import java.util.ArrayList; + +public class BlackJack_Player extends Player implements Gambling { + + private Person player; + Integer bet; + + + + + public BlackJack_Player(Person player) { + super(player); + } + + public Boolean didWin(){ return false;} + public void makeMove(){} + public void leaveGame(){} + /* public Boolean canSplit(){ + + if(playerHand.get(0) == playerHand.get(1)){ + return true; + } + return false;}*/ + public void split() {} + public void hitOrStay() {} + public void doubleDown() {} + + @Override + public Integer bet(Integer numOfChipsToBet) { + return null; + } +} diff --git a/src/main/java/Card.java b/src/main/java/Card.java new file mode 100644 index 000000000..767a2af47 --- /dev/null +++ b/src/main/java/Card.java @@ -0,0 +1,57 @@ +public class Card { + + private Integer faceUp; + private Rank rank; + private Suit suit; + + public Card(Integer faceUp, Rank rank, Suit suit) { + this.faceUp = faceUp; + this.rank = rank; + this.suit = suit; + } + + public void setFaceDownToEveryone() { + this.faceUp = -1; + } + public void setFaceUpToMe() { + this.faceUp = 0; + } + public void setFaceUpToEveryone() { + this.faceUp = 1; + } + public Boolean isFaceDownToEveryone() { + return (faceUp == -1); + } + public Boolean isFaceUpToMe() { + return (faceUp == 0); + } + public Boolean isFaceUpToEveryone() { + return (faceUp == 1); + } + + public Integer getRankNumber() { + return rank.getRankNumber(); + } + public Rank getRank() {return rank;} + + public Suit getSuit() { + return suit; + } + + public Integer getValue() { + if (isFaceDownToEveryone() | isFaceUpToMe()) return 0; + return getRankNumber(); + } + + + public void flip() { + if (isFaceDownToEveryone()) setFaceUpToEveryone(); + else if (isFaceUpToEveryone()) setFaceDownToEveryone(); + else if (isFaceUpToMe()) setFaceUpToEveryone(); + } + + @Override + public String toString() { + return rank.getRankString()+suit.getSuitImage(); + } +} diff --git a/src/main/java/CardComparator.java b/src/main/java/CardComparator.java new file mode 100644 index 000000000..850fd72f8 --- /dev/null +++ b/src/main/java/CardComparator.java @@ -0,0 +1,14 @@ +import java.util.Comparator; + +public class CardComparator implements Comparator { + + @Override + public int compare(Card cardOne, Card cardTwo) { + + Integer value = cardOne.getRankNumber()-cardTwo.getRankNumber(); + + if (value == 0) + value = cardOne.getSuit().compareTo(cardTwo.getSuit()); + return value; + } +} diff --git a/src/main/java/CardGame.java b/src/main/java/CardGame.java new file mode 100644 index 000000000..566ceffbc --- /dev/null +++ b/src/main/java/CardGame.java @@ -0,0 +1,17 @@ +import java.util.ArrayList; + +abstract class CardGame extends Game{ + + private Decks decks; + + public CardGame(Player[] players, Integer numberOfDecks) { + super(players); + this.decks = new Decks(numberOfDecks); + } + + public CardGame(Player players, Integer numberOfDecks) { + super(players); + this.decks = new Decks(numberOfDecks); + } + +} diff --git a/src/main/java/CeeLo.java b/src/main/java/CeeLo.java new file mode 100644 index 000000000..e5872d0d5 --- /dev/null +++ b/src/main/java/CeeLo.java @@ -0,0 +1,27 @@ +import java.util.ArrayList; + +public class CeeLo extends DiceGame { + private Integer pool; + + public CeeLo(CeeLoPlayer ...player) { + super(player, 3); + } + + public void takeTurn( ){} + public void setNumber(){} + public Integer getNumberToBeat(){ + return 0; + } + + Boolean didWin(Player player) { + return null; + } + + void playGame() { + + } + + void endOfGame() { + + } +} diff --git a/src/main/java/CeeLoPlayer.java b/src/main/java/CeeLoPlayer.java new file mode 100644 index 000000000..aa2914d8b --- /dev/null +++ b/src/main/java/CeeLoPlayer.java @@ -0,0 +1,5 @@ +public class CeeLoPlayer extends Player{ + public CeeLoPlayer(Person p) { + super(p); + } +} diff --git a/src/main/java/CeeLoTurn.java b/src/main/java/CeeLoTurn.java new file mode 100644 index 000000000..1802b29c0 --- /dev/null +++ b/src/main/java/CeeLoTurn.java @@ -0,0 +1,14 @@ +import java.util.ArrayList; + +public class CeeLoTurn extends Turn { + private ArrayList bin; + public void move(){ } + public Integer roll() {return 0;} + public Integer compare(){return 1;} + public boolean checkWin(){return true;} + + @Override + Boolean validMove() { + return null; + } +} diff --git a/src/main/java/Chips.java b/src/main/java/Chips.java new file mode 100644 index 000000000..c4045e2bf --- /dev/null +++ b/src/main/java/Chips.java @@ -0,0 +1,11 @@ +public class Chips { + private Integer chips; + + public Integer getChips() { + return chips; + } + + public Chips(Double moneyForChips) { + this.chips = (int)Math.floor(moneyForChips/5.0); + } +} diff --git a/src/main/java/io/zipcoder/casino/utilities/Console.java b/src/main/java/Console.java similarity index 97% rename from src/main/java/io/zipcoder/casino/utilities/Console.java rename to src/main/java/Console.java index ab896c956..d35623b51 100644 --- a/src/main/java/io/zipcoder/casino/utilities/Console.java +++ b/src/main/java/Console.java @@ -1,6 +1,3 @@ -package io.zipcoder.casino.utilities; - - import java.io.InputStream; import java.io.PrintStream; import java.util.Scanner; diff --git a/src/main/java/DStyleCrapsPlayer.java b/src/main/java/DStyleCrapsPlayer.java new file mode 100644 index 000000000..e38c48f19 --- /dev/null +++ b/src/main/java/DStyleCrapsPlayer.java @@ -0,0 +1,27 @@ +public class DStyleCrapsPlayer extends Player{ + Person person; + Integer chips; + public DStyleCrapsPlayer(Person player) { + this.person=player; + House house=new House(2, null); + chips=house.moneyToChips(20.0); + + } + + public Integer roll(Dice dice){ + Integer total= dice.tossAndSum(); + return total; + } + public Integer numOfChips(){ + if (person.getWallet()==0) + return null; + else + return chips; + + } + public Integer bet(Integer betChips){ + chips=chips-betChips; + return betChips; + } + +} diff --git a/src/main/java/DStyleCrapsTurn.java b/src/main/java/DStyleCrapsTurn.java new file mode 100644 index 000000000..a3340cc53 --- /dev/null +++ b/src/main/java/DStyleCrapsTurn.java @@ -0,0 +1,6 @@ +public class DStyleCrapsTurn extends Turn { + @Override + Boolean validMove() { + return null; + } +} diff --git a/src/main/java/Dealer.java b/src/main/java/Dealer.java new file mode 100644 index 000000000..8d527e05f --- /dev/null +++ b/src/main/java/Dealer.java @@ -0,0 +1,6 @@ + + +public interface Dealer { + Card dealCard(); + void shuffle(); +} diff --git a/src/main/java/Decks.java b/src/main/java/Decks.java new file mode 100644 index 000000000..4cee6a423 --- /dev/null +++ b/src/main/java/Decks.java @@ -0,0 +1,26 @@ +import jdk.nashorn.internal.runtime.arrays.ArrayLikeIterator; + +import java.lang.reflect.Array; +import java.util.ArrayList; + +public class Decks { + private ArrayList cards; + + public Decks(Integer numberOfDecks) { + this.cards = new ArrayList<>(numberOfDecks*52); + ArrayList deckOfCards = buildOneDeck(); + for (int i = 0; i < numberOfDecks; i++) cards.addAll(deckOfCards); + } + + protected ArrayList getCards() { + return cards; + } + + protected ArrayList buildOneDeck() { + ArrayList deck = new ArrayList<>(52); + for (Suit suit : Suit.values()) { + for (Rank rank : Rank.values()) deck.add(new Card(-1, rank, suit)); + } + return deck; + } +} diff --git a/src/main/java/Dice.java b/src/main/java/Dice.java new file mode 100644 index 000000000..14306eff5 --- /dev/null +++ b/src/main/java/Dice.java @@ -0,0 +1,32 @@ +public class Dice { + private Integer[] dice; + public Dice(Integer numberOfDice) { + this.dice = new Integer[numberOfDice]; + } + public Integer toss() { + return ((int)(Math.random()*6) + 1); + + + } + public Integer tossAndSum() { + Integer sum=0; + int j=0; + for(int i=0;i makeDice(Integer numberOfDice) {return new ArrayList();} + + +} diff --git a/src/main/java/DolioStyleCraps.java b/src/main/java/DolioStyleCraps.java new file mode 100644 index 000000000..a69f07415 --- /dev/null +++ b/src/main/java/DolioStyleCraps.java @@ -0,0 +1,31 @@ +import java.util.ArrayList; + +public class DolioStyleCraps extends DiceGame { + public DolioStyleCraps(DStyleCrapsPlayer[] players) { + super(players, 2); + } + + + public void playGame() { + ((DStyleCrapsPlayer) players[0]).roll(dice); + } + + public Boolean didWin(DStyleCrapsPlayer player) { + if(dice.sum()==7||dice.sum()==11) + return true; + else if(dice.sum()==2) + return false; + else + playGame(); + return false; + } + + public void endOfGame() { + if(didWin((DStyleCrapsPlayer)players[0])==true) + System.out.println("Player "+players[0]+" won the game"); + else if(didWin((DStyleCrapsPlayer)players[0])==false) + System.out.println("Player "+players[0]+" lost the game"); + else + playGame(); + } +} diff --git a/src/main/java/Gambling.java b/src/main/java/Gambling.java new file mode 100644 index 000000000..783fe8a06 --- /dev/null +++ b/src/main/java/Gambling.java @@ -0,0 +1,5 @@ +import exceptions.NegativeBetException; + +public interface Gambling { + Integer bet(Integer numOfChipsToBet) throws NegativeBetException; +} diff --git a/src/main/java/Game.java b/src/main/java/Game.java new file mode 100644 index 000000000..f2f943b69 --- /dev/null +++ b/src/main/java/Game.java @@ -0,0 +1,23 @@ +import java.lang.reflect.Array; +import java.util.ArrayList; + +public abstract class Game { + + protected Player[] players; + protected Player player; + + public Game(Player[] players) { + this.players = players; + } + public Game(){} + + public Game(Player player) { + this.player = player; + } + + // abstract Boolean didWin(Player player); + abstract void playGame(); + abstract void endOfGame(); + + +} diff --git a/src/main/java/Hand.java b/src/main/java/Hand.java new file mode 100644 index 000000000..7b2482d0a --- /dev/null +++ b/src/main/java/Hand.java @@ -0,0 +1,29 @@ +import java.util.ArrayList; + +public abstract class Hand { + private ArrayList cards; + + public Hand(ArrayList cards) { + this.cards = cards; + } + + public void sort() { + CardComparator comparator = new CardComparator(); + cards.sort(comparator); + } + + public void addCard(Card newCard) { + cards.add(newCard); + } + + public Card[] playCard(int ...index) { + Card[] cardsToPlay = new Card[index.length]; + int count = 0; + for (int i : index) cardsToPlay[count] = cards.remove(i); + return cardsToPlay; + } + + public Integer numberOfCardsInHand() { + return cards.size(); + } +} diff --git a/src/main/java/House.java b/src/main/java/House.java new file mode 100644 index 000000000..beee35b26 --- /dev/null +++ b/src/main/java/House.java @@ -0,0 +1,61 @@ + +import java.util.Collections; +import java.util.Random; + +public class House implements Dealer { + + + public void payout() {} + public void takeBets() {} + + + private Integer houseWallet; + private Integer payoutRatio; + private Decks decks; + + + public House(Integer payoutRatio, Decks decks) { + this.houseWallet = 0; + this.payoutRatio = payoutRatio; + this.decks = decks; + + } + + public Integer payout(Integer originalBetAmount) { + Integer payout = payoutRatio*originalBetAmount; + houseWallet -= payout; + return payout; + } + + public void takeBets(Integer ...chips) { + for (Integer chip : chips) houseWallet += payoutRatio*chip; + } + + public Integer moneyToChips(Double moneyAmount) { + return (int)Math.floor(moneyAmount/5.0); + } + public Integer getHouseWallet() { + return houseWallet; + } + + public void setHouseWallet(Integer houseWallet) { + this.houseWallet = houseWallet; + } + + public Integer getPayoutRatio() { + return payoutRatio; + } + public Decks getDecks() { + return decks; + } + + @Override + public Card dealCard() { + return decks.getCards().remove(0); + } + + @Override + public void shuffle() { + Collections.shuffle(decks.getCards()); + } +} diff --git a/src/main/java/Lounge.java b/src/main/java/Lounge.java new file mode 100644 index 000000000..da988d72f --- /dev/null +++ b/src/main/java/Lounge.java @@ -0,0 +1,4 @@ +public class Lounge extends PrasanthiPalace { + + public void chooseGame() { } +} diff --git a/src/main/java/Mediator.java b/src/main/java/Mediator.java new file mode 100644 index 000000000..6422a308b --- /dev/null +++ b/src/main/java/Mediator.java @@ -0,0 +1,132 @@ +import java.lang.reflect.Array; +import java.util.ArrayList; + +public class Mediator { + private Console console; + private Person person; + private Boolean gameContinue; + + public Mediator() { + this.console = new Console(System.in, System.out); + gameContinue = true; + } + + + public void enterLounge(){ + console.println("Welcome to our casino, Prasanthi's Palace!"); + this.person = makePerson(); + console.println("You are currently in the lounge"); + printOptions(); + while (gameContinue) { + String input = console.getStringInput("What would you like to do?"); + parseInput(input); + } + } + + + private void playCraps() { + } + + private void playBlackJack() { + } + + + private void playCeeLo() { + } + + private void playPoker() { + + } + + private void playPalace() { + } + + public Person makePerson() { + console.println("Tell us a little about yourself"); + Integer age = console.getIntegerInput("How old are you?"); + String name = console.getStringInput("What's your name?"); + //Double wallet = (age >= 21) ? console.getDoubleInput("How much money do you want to bet today?") : 0.0; + Double wallet = console.getDoubleInput("How much money have you brought with you today?"); + return new Person(wallet, name, age); + } + + public void printOptions() { + console.println("There are five games available to play :"); + console.print("1) Palace\n2) Texas Hold 'Em\n3) Black Jack\n4) Cee-lo\n5) Dolio Style Craps\n"); + console.println("While in the lounge you can get a drink or a bite to eat."); + console.println("Let us know what you want to do"); + } + + public void getDrink() { + console.println("Welcome to Will's Watering Hole"); + if (person.getWallet() <= 0) console.println("Remember, our drinks cost money. Would you like some water?"); + else { + String drink = console.getStringInput("I can make you any drink, any way you want. What would you like?"); + console.println(String.format("%s, served just the way you like it. That'll be 8 dollars", drink)); + String finished = console.getStringInput("Done drinking?"); + if (finished.equals("yes")) console.println("Sorry, we have a one drink limit. You'll have to leave now"); + else console.println("Too bad, someone else needs your stool. Take your drink with you."); + } + console.println("You have returned to our luxurious lounge."); + } + public void getFood() { + console.println("Welcome to Stefun's Sustainable Eatery"); + if (person.getWallet() <= 0) console.println("C'mon, how're you going to eat without any money. You can have some water."); + else { + String food = console.getStringInput("We can make just about anything. What do you want?"); + console.println(String.format("%s, straight from the kitchen.", food)); + String finished = console.getStringInput("Done eating?"); + if (finished.equals("yes")) console.println("Sorry, we have quite the wait. I'd appreciate it if you leave"); + else console.println("Too bad, someone else needs your table. Here's a container for your food."); + } + console.println("You have returned to the beautiful lounge."); + } + + public String parseInput(String input){ + Action action = new Action(input); + Act act = action.getAct(); + switch (act) { + case QUIT: + leaveGame(); + break; + case PLAY: + printOptions(); + break; + case DRINK: + getDrink(); + break; + case EAT: + getFood(); + break; + case PALACE: + playPalace(); + break; + case POKER: + playPoker(); + break; + case CEELO: + playCeeLo(); + break; + case BLACKJACK: + playBlackJack(); + break; + case CRAPS: + playCraps(); + break; + case LOUNGE: + enterLounge(); + break; + } + return "We're not sure what you meant by that. Can you be more specific?"; + } + + private void leaveGame() { + console.println("We're sorry to see you go!"); + gameContinue = false; + } + + public Boolean checkAge() { + if (person == null) return false; + return (person.getAge() >= 21); + } +} diff --git a/src/main/java/Palace.java b/src/main/java/Palace.java new file mode 100644 index 000000000..2dbf91250 --- /dev/null +++ b/src/main/java/Palace.java @@ -0,0 +1,18 @@ +import com.sun.org.apache.xpath.internal.operations.Bool; + +import javax.print.attribute.standard.PrinterLocation; +import java.util.ArrayList; + +public class Palace extends CardGame { + +// PileOfCards deck = new PileOfCards(); + PileOfCards discard; + + public Palace (Player[] players , Integer numberOfDecks) { + super(players, numberOfDecks); + + } + public Boolean didWin(Player player) {return false;} + public void playGame() {} + public void endOfGame() {} +} diff --git a/src/main/java/PalaceHand.java b/src/main/java/PalaceHand.java new file mode 100644 index 000000000..09f9266b3 --- /dev/null +++ b/src/main/java/PalaceHand.java @@ -0,0 +1,7 @@ +import java.util.ArrayList; + +public class PalaceHand extends Hand { + public PalaceHand(ArrayList cards) { + super(cards); + } +} diff --git a/src/main/java/PalacePlayer.java b/src/main/java/PalacePlayer.java new file mode 100644 index 000000000..1d65620cd --- /dev/null +++ b/src/main/java/PalacePlayer.java @@ -0,0 +1,20 @@ +public class PalacePlayer implements Dealer{ + + Hand hand; + + public PalacePlayer(Person player) { + + // this.hand = new PalaceHand(); + } + + + @Override + public Card dealCard() { + return null; + } + + @Override + public void shuffle() { + + } +} diff --git a/src/main/java/PalaceTurn.java b/src/main/java/PalaceTurn.java new file mode 100644 index 000000000..0e90918d9 --- /dev/null +++ b/src/main/java/PalaceTurn.java @@ -0,0 +1,3 @@ +public class PalaceTurn extends Turn { + public Boolean validMove() {return false;} +} diff --git a/src/main/java/Person.java b/src/main/java/Person.java new file mode 100644 index 000000000..2c669930f --- /dev/null +++ b/src/main/java/Person.java @@ -0,0 +1,38 @@ +public class Person { + private Double wallet; + private String name; + private Integer age; + + public Person(Double wallet, String name, Integer age) { + this.wallet = wallet; + this.name = name; + this.age = age; + } + + + public Double getWallet() { + return wallet; + } + + public void setWallet(Double wallet) { + this.wallet = wallet; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Integer getAge() { + return age; + } + + public void setAge(Integer age) { + this.age = age; + } + + +} diff --git a/src/main/java/PileOfCards.java b/src/main/java/PileOfCards.java new file mode 100644 index 000000000..11cc89bf2 --- /dev/null +++ b/src/main/java/PileOfCards.java @@ -0,0 +1,38 @@ +import java.util.ArrayList; +import java.util.EmptyStackException; +import java.util.Stack; + +public class PileOfCards { + + private Stack cards; + + public PileOfCards() { + this.cards = new Stack(); + } + + public void clear() { + while (!cards.isEmpty()) cards.pop(); + } + + public void addAll(ArrayList cardsToAdd) { + while (cardsToAdd.size() > 0) { + this.cards.push(cardsToAdd.remove(cardsToAdd.size()-1)); + } + } + public void add(Card card) { + cards.push(card); + } + + public Card remove() { + try { + return cards.pop(); + } catch (EmptyStackException ex) { + return null; + } + } + public Stack getCards() { + return cards; + } + + +} diff --git a/src/main/java/Player.java b/src/main/java/Player.java new file mode 100644 index 000000000..5ef6c831d --- /dev/null +++ b/src/main/java/Player.java @@ -0,0 +1,11 @@ +public abstract class Player { + private Person person; + + public Player(Person p) { + person = p; + } + + public Player() { + + } +} diff --git a/src/main/java/PlayerNotFoundException.java b/src/main/java/PlayerNotFoundException.java new file mode 100644 index 000000000..7e378e8b9 --- /dev/null +++ b/src/main/java/PlayerNotFoundException.java @@ -0,0 +1,6 @@ +public class PlayerNotFoundException extends Exception { + + public PlayerNotFoundException(String message){ + super(message); + } +} diff --git a/src/main/java/Poker.java b/src/main/java/Poker.java new file mode 100644 index 000000000..20d79d58c --- /dev/null +++ b/src/main/java/Poker.java @@ -0,0 +1,155 @@ +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +public class Poker extends CardGame { + + List communityCard; + Integer pool = 0; + Integer lastBet = 0; + Integer sameBetCount = 0; + List pokerPlayerList; // to store all player + Console console; + House house; + + public Poker(PokerPlayer player, Console console) { + super(player, 1); + this.console = console; + pokerPlayerList = new ArrayList<>(); + /* TODO: after the changes of Players array to Single player, store the + * TODO: player to list and make some poker AI into the list + * */ + + } + + public void playGame() { + while (!onePlayerStanding() && !showDownTime()) { + initializeBet(); + determineTurnToPlay(); + } + PokerPlayer winner = showDown(); + awardPool(winner); + endOfGame(); + } + + private void determineTurnToPlay() { + if (communityCard.size() == 0) + preFlop(); + else + postFlop(); + } + + private void preFlop() { + update(pokerPlayerList.get(0).smallBlind()); + update(pokerPlayerList.get(1).bigBlind()); + // dealtCard + startBetting(2); + // flop + } + + + private void postFlop() { + startBetting(0); + // if is not showDown time, add card + } + + private PokerPlayer showDown() { + // make an array of everyone's point + // for each player + // determine the point they got by add communityCard + player hand + // send it to evalulate + // return winner + + + return null; + } + + private Boolean showDownTime() { + return communityCard.size() >= 5; + } + + public void startBetting(Integer startingPlayerIndex) { + Integer currentPlayerIndex = startingPlayerIndex; + + // keep betting when everyone hasn't bet same + // and when there is still 2 or more unfolded player + while(!onePlayerStanding() && !everyoneBetSame()) + { + if (!pokerPlayerList.get(currentPlayerIndex).isFolded()) + update(pokerPlayerList.get(currentPlayerIndex).getBetFromAction(console, lastBet)); + + currentPlayerIndex++; + if (currentPlayerIndex >= pokerPlayerList.size()) + currentPlayerIndex = 0; + } + } + + private void initializeBet() { + lastBet = 0; + sameBetCount = 0; + } + + private void update(Integer betFromAction) { + if (betFromAction != null) { + updatePool(betFromAction); + updateSameBetCount(betFromAction); + updateLastBet(betFromAction); + } + } + + private void updatePool(Integer betFromAction) { + pool += betFromAction; + } + + + private void updateSameBetCount(Integer betFromAction) { + if (betFromAction.equals(lastBet)) + sameBetCount++; + else + sameBetCount = 0; + } + + private void updateLastBet(Integer betFromAction) { + lastBet = betFromAction; + } + + private Boolean isNPC(PokerPlayer player) { + return player instanceof PokerNPC; + } + + private Integer getNumOfFoldedPlayer() + { + Integer numOfFoldedPlayer = 0; + for (PokerPlayer pokerPlayer : pokerPlayerList) + if (pokerPlayer.isFolded()) + numOfFoldedPlayer++; + + return numOfFoldedPlayer; + } + + private Boolean onePlayerStanding() { + + + return getNumOfFoldedPlayer() == pokerPlayerList.size()-1; + } + + private Boolean everyoneBetSame() { + return sameBetCount == pokerPlayerList.size() - getNumOfFoldedPlayer(); + } + + private void awardPool(PokerPlayer winner) { + winner.addChips(pool); + pool = 0; + } + + + public void endOfGame() { + // ask if keep playing + // if keep playing + // reset bet + // change seat + // call playGame + } + + public void resetLastBet() {lastBet = 0;} +} diff --git a/src/main/java/PokerHand.java b/src/main/java/PokerHand.java new file mode 100644 index 000000000..10095c6d3 --- /dev/null +++ b/src/main/java/PokerHand.java @@ -0,0 +1,8 @@ +import java.util.ArrayList; + +public class PokerHand extends Hand { + + public PokerHand(ArrayList cards) { + super(cards); + } +} diff --git a/src/main/java/PokerHandEvaluator.java b/src/main/java/PokerHandEvaluator.java new file mode 100644 index 000000000..3270c42a8 --- /dev/null +++ b/src/main/java/PokerHandEvaluator.java @@ -0,0 +1,113 @@ +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class PokerHandEvaluator { + + // STRAIGHT_FLUSH (2), good + // FOUR_OF_A_KIND (3), good + // FULL_HOUSE (4), good + // FLUSH (5), good + // STRAIGHT (6), good + // THREE_OF_A_KIND (7), good + // TWO_PAIR (8), good + // PAIR (9), good + +// public static Boolean isStraightFlush(ArrayList cards) { +// return isFlush(getStrightCard(cards)); +// } + + public static Boolean isFourOfAKind(ArrayList cards) { + return isRepeatRank(cards,4); + } + + public static Boolean isFullHouse(ArrayList cards) { + if (isThreeOfAKind(cards)) { + // ArrayList remaining = cardsExclude3Kind(cards); + // if (isPair(remaining)) + return true; + } + return false; + } + + + public static Boolean isFlush(ArrayList cards) + { + for (Suit suit : Suit.values()){ + Integer suitCount = 0; + + for (Card card: cards) + if (card.getSuit() == suit) + suitCount++; + + if (suitCount >= 5) return true; + } + return false; + } + + public static Boolean isStraight(ArrayList cards) { + cards.sort(new CardComparator()); + + for(Integer i = 0; i < cards.size(); i++) + { + Integer count = 0; + Integer currentRankNumber = cards.get(i).getRankNumber(); + + for (Integer j = i; j < cards.size(); j++) { + if (cards.get(j).getRankNumber() == currentRankNumber + 1) + { + count++; + currentRankNumber++; + } + if (count >= 5) + return true; + } + } + return false; + } + + public static Boolean isThreeOfAKind(ArrayList cards) { + return isRepeatRank(cards,3); + } + + public static Boolean isTwoPair(ArrayList cards) { + Integer excludeRank = null; + + for(Integer i = 0; i < cards.size(); i++) + { + Integer count = 0; + Integer currentRankNumber = cards.get(i).getRankNumber(); + for (Integer j = i; j < cards.size(); j++) { + if (cards.get(j).getRankNumber().equals(currentRankNumber)) + count++; + + if (count >= 2) + excludeRank = currentRankNumber; + + } + } + return false; + } + + public static Boolean isPair(ArrayList cards) { + return isRepeatRank(cards,2); + } + + public static Boolean isRepeatRank(ArrayList cards, Integer numOfRepeat) + { + for(Integer i = 0; i < cards.size(); i++) + { + Integer count = 0; + Integer currentRankNumber = cards.get(i).getRankNumber(); + for (Integer j = i; j < cards.size(); j++) { + if (cards.get(j).getRankNumber().equals(currentRankNumber)) + count++; + + if (count >= numOfRepeat) + return true; + } + } + return false; + } + +} diff --git a/src/main/java/PokerNPC.java b/src/main/java/PokerNPC.java new file mode 100644 index 000000000..396d05897 --- /dev/null +++ b/src/main/java/PokerNPC.java @@ -0,0 +1,11 @@ +public class PokerNPC extends PokerPlayer{ + + public PokerNPC(Person p) { + super(p); + } + + @Override + public Integer getBetFromAction(Console console, Integer lastBet) { + return 0; + } +} diff --git a/src/main/java/PokerPlayer.java b/src/main/java/PokerPlayer.java new file mode 100644 index 000000000..ea33032a8 --- /dev/null +++ b/src/main/java/PokerPlayer.java @@ -0,0 +1,70 @@ +import exceptions.NegativeBetException; +import exceptions.NotEnoughChipException; + +public class PokerPlayer extends Player implements Gambling { + private PokerHand hand; + private Boolean folded = false; + private Integer chips = 0; + + public PokerPlayer(Person p) { + super(p); + } + + public Integer call(Integer lastPlayerBet) { + return bet(lastPlayerBet); + } + + public Integer check() {return call(0);} + + public void fold() { + folded = true; + } + public void getReady() { folded = false; } + + + public Integer raise(Integer lastPlayerBet, Integer amountToRaise) throws NegativeBetException { + if (amountToRaise < 0) + throw new NegativeBetException(); + return bet(lastPlayerBet + amountToRaise); + } + + public Integer smallBlind() { + return bet(1); + } + + public Integer bigBlind() { + return bet(2); + } + + public Boolean isFolded() { + return folded; + } + + public Integer getChip() { + return chips; + } + + public void setChips(Integer chips) { + this.chips = chips; + } + + public void addChips(Integer chips) { this.chips += chips; } + + public Integer bet(Integer numOfChipsToBet) throws NegativeBetException, NotEnoughChipException { + if (numOfChipsToBet < 0) + throw new NegativeBetException(); + if(numOfChipsToBet > chips) + throw new NotEnoughChipException("Not enough Chips"); + chips -= numOfChipsToBet; + return numOfChipsToBet; + } + + public Integer getBetFromAction(Console console, Integer lastBet) { + while(true) { + Integer choice = console.getIntegerInput("1. Call 2. Raise 3. Fold"); + if (choice == 1) return call(lastBet); + else if (choice == 2) return raise(lastBet, console.getIntegerInput("How much?")); + else if (choice == 3) {fold(); return null;} + } + } +} diff --git a/src/main/java/PokerTurn.java b/src/main/java/PokerTurn.java new file mode 100644 index 000000000..8813309fc --- /dev/null +++ b/src/main/java/PokerTurn.java @@ -0,0 +1,39 @@ +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class PokerTurn extends Turn { + public Boolean validMove() { + return false; + } + + + public void startBetting() { + // loop { + // next person choose from fold, call, raise + // end loop if both condition are met + // 1. everyone who is not folded bet same amount + // 2. everyone acted + // OR + // number of folded player == players.size-1 (the one left wins) + // } + } + + public static Integer[] subArray(Integer[] a, Integer i, Integer j) + { + return Arrays.copyOfRange(a, i, j); + } +} + +// First turn +// next person small blind +// next person big blind +// distribute two card for each player +// startBetting() +// set 3 card on communityCard (flop) +// startBetting() +// add a card +// startBetting() +/// add a card +// startBetting() + diff --git a/src/main/java/PrasanthiCard.java b/src/main/java/PrasanthiCard.java new file mode 100644 index 000000000..e6f7bbd52 --- /dev/null +++ b/src/main/java/PrasanthiCard.java @@ -0,0 +1,47 @@ +public class PrasanthiCard { + public PrasanthiCard() { + + } + + private static String drawBack() { + return "+-----+\n" + "||\n" + + "| ~ |\n" + "| P |\n" + + "+-----+"; + //24c5 + } + + public static String drawCard(Rank rank, Suit suit) { + return String.format("+-----+\n" + "|%s|\n" + + "|%2s|\n" + "|%s|\n" + + "+-----+", rank.getRankImage(), suit.getSuitImage(), rank.getRankImage()); + } + + private static String drawFirstCardRow() { + return " +------+ "; + } + private static String drawRankCardRow(String rankImage) { + return String.format(" | %s | ", rankImage); + } + private static String drawSuitCardRow(String suitImage) { + return String.format(" | %2s | ", suitImage); + } + + public static void drawAllCards() { + for(Rank rank : Rank.values()) System.out.print(drawFirstCardRow()); + System.out.println(); + for(Rank rank : Rank.values()) System.out.print(drawRankCardRow(rank.getRankImage())); + System.out.println(); + for(Rank rank : Rank.values()) System.out.print(drawSuitCardRow(Suit.HEART.getSuitImage())); + System.out.println(); + for(Rank rank : Rank.values()) System.out.print(drawRankCardRow(rank.getRankImage())); + System.out.println(); + for(Rank rank : Rank.values()) System.out.print(drawFirstCardRow()); + +// System.out.println(drawBack()); + } +// +// +// +// System.out.println(drawFirstCardRow()); + +} diff --git a/src/main/java/PrasanthiPalace.java b/src/main/java/PrasanthiPalace.java new file mode 100644 index 000000000..4b56c1e0b --- /dev/null +++ b/src/main/java/PrasanthiPalace.java @@ -0,0 +1,12 @@ +public class PrasanthiPalace { + + public static void main(String[] args) { + // write your tests before you start fucking with this + run(); + } + public static void run() { + Mediator mediator = new Mediator(); + mediator.enterLounge(); + + } +} diff --git a/src/main/java/Rank.java b/src/main/java/Rank.java new file mode 100644 index 000000000..9077f8c8f --- /dev/null +++ b/src/main/java/Rank.java @@ -0,0 +1,35 @@ +public enum Rank { + ACE (1, "A", "\u24b6"), + TWO (2, "2", "\u2461"), + THREE (3, "3", "\u2462"), + FOUR (4, "4", "\u2463"), + FIVE (5, "5", "\u2464"), + SIX (6, "6", "\u2465"), + SEVEN (7, "7", "\u2466"), + EIGHT (8, "8", "\u2467"), + NINE (9, "9","\u2468"), + TEN (10, "10", "\u2469"), + JACK (11, "J", "\u24bf"), + QUEEN (12, "Q", "\u24c6"), + KING (13, "K", "\u24c0"); + + public Integer getRankNumber() { + return rankNumber; + } + + public String getRankString() { + return rankString; + } + public String getRankImage() { return rankImage; } + + private final Integer rankNumber; + private final String rankString; + private final String rankImage; + + Rank(Integer rankNumber, String rankString, String rankImage) { + this.rankNumber = rankNumber; + this.rankString = rankString; + this.rankImage = rankImage; + + } +} diff --git a/src/main/java/Suit.java b/src/main/java/Suit.java new file mode 100644 index 000000000..b26779d1f --- /dev/null +++ b/src/main/java/Suit.java @@ -0,0 +1,21 @@ +public enum Suit { + DIAMOND ("Diamonds", "\u2666"), + HEART ("Hearts", "\u2665"), + SPADE ("Spades", "\u2660"), + CLUB ("Clubs", "\u2663"); + + public String getSuitString() { + return suitString; + } + + public String getSuitImage() { + return suitImage; + } + + private final String suitString; + private final String suitImage; + Suit(String suitString, String suitImage) { + this.suitImage = suitImage; + this.suitString = suitString; + } +} diff --git a/src/main/java/Turn.java b/src/main/java/Turn.java new file mode 100644 index 000000000..27ca97074 --- /dev/null +++ b/src/main/java/Turn.java @@ -0,0 +1,3 @@ +public abstract class Turn { + abstract Boolean validMove(); +} diff --git a/src/main/java/exceptions/NegativeBetException.java b/src/main/java/exceptions/NegativeBetException.java new file mode 100644 index 000000000..0fdfc2b68 --- /dev/null +++ b/src/main/java/exceptions/NegativeBetException.java @@ -0,0 +1,8 @@ +package exceptions; + + +public class NegativeBetException extends RuntimeException { + public NegativeBetException() + {super("Invalid number of Chips");} +} + diff --git a/src/main/java/exceptions/NotEnoughChipException.java b/src/main/java/exceptions/NotEnoughChipException.java new file mode 100644 index 000000000..613907f86 --- /dev/null +++ b/src/main/java/exceptions/NotEnoughChipException.java @@ -0,0 +1,8 @@ +package exceptions; + + +public class NotEnoughChipException extends RuntimeException { + public NotEnoughChipException(String errorMessage) + {super(errorMessage);} +} + diff --git a/src/main/java/io/zipcoder/casino/Casino.java b/src/main/java/io/zipcoder/casino/Casino.java deleted file mode 100644 index 16ca0dd74..000000000 --- a/src/main/java/io/zipcoder/casino/Casino.java +++ /dev/null @@ -1,8 +0,0 @@ -package io.zipcoder.casino; - - -public class Casino { - public static void main(String[] args) { - // write your tests before you start fucking with this - } -} diff --git a/src/test/java/ActionTest.java b/src/test/java/ActionTest.java new file mode 100644 index 000000000..e7dacd1ab --- /dev/null +++ b/src/test/java/ActionTest.java @@ -0,0 +1,35 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class ActionTest { + + @Test + public void lookupTest() { + //Given + String input = "end"; + Action action = new Action(input); + String expected = "quit"; + String actual = action.toActionString(); + assertEquals(expected, actual); + } + + @Test + public void getActTest() { + String input = "QUIT"; + Action action = new Action(input); + Act expected = Act.QUIT; + Act actual = action.getAct(); + assertEquals(expected, actual); + } + + @Test + public void normalizeInput() { + String input = "QuIT"; + Action action = new Action(input); + String expected = "quit"; + String actual = action.normalizeInput(); + assertEquals(expected, actual); + } + +} \ No newline at end of file diff --git a/src/test/java/BlackJackHandTest.java b/src/test/java/BlackJackHandTest.java new file mode 100644 index 000000000..aea0f3b25 --- /dev/null +++ b/src/test/java/BlackJackHandTest.java @@ -0,0 +1,9 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class BlackJackHandTest { + @Test + public void name() { + } +} \ No newline at end of file diff --git a/src/test/java/BlackJackTest.java b/src/test/java/BlackJackTest.java new file mode 100644 index 000000000..66e9a1691 --- /dev/null +++ b/src/test/java/BlackJackTest.java @@ -0,0 +1,44 @@ +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.*; + +public class BlackJackTest { + + @Before + public void setUp() throws Exception { + ArrayList playerHand = new ArrayList<>(5); + Card card1 = new Card(1,Rank.TEN, Suit.CLUB); + Card card2 = new Card(1,Rank.TEN, Suit.CLUB); + playerHand.add(0,card1); + playerHand.add(1,card2); + } + +// @After +// public void tearDown() throws Exception { +// playerHand = null; +// assertNull(playerHand); +// } + + @Test + public Boolean canSplit(){ + return false; + + } + + @Test + public void name() { + + } + + @Test + public void playGame() { + } + + @Test + public void endOfGame() { + } +} \ No newline at end of file diff --git a/src/test/java/BlackJack_PlayerTest.java b/src/test/java/BlackJack_PlayerTest.java new file mode 100644 index 000000000..20d046338 --- /dev/null +++ b/src/test/java/BlackJack_PlayerTest.java @@ -0,0 +1,41 @@ +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.*; + +public class BlackJack_PlayerTest { + BlackJack_Player player1; + + @Before + public void setUp() throws Exception { + BlackJack_Player player1 = new BlackJack_Player(new Person(1000.00,"Stefun", 34)); + BlackJack_Player [] players = new BlackJack_Player[3]; + players[0] = player1; + BlackJack blackJack1 = new BlackJack(players, 5); + + } + + @After + public void tearDown() throws Exception { + } + + + @Test + public void split() { + } + + @Test + public void hitOrStay() { + } + + @Test + public void doubleDown() { + } + + @Test + public void bet() { + } +} \ No newline at end of file diff --git a/src/test/java/CardComparatorTest.java b/src/test/java/CardComparatorTest.java new file mode 100644 index 000000000..bd329d59d --- /dev/null +++ b/src/test/java/CardComparatorTest.java @@ -0,0 +1,25 @@ +import org.junit.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.*; + +public class CardComparatorTest { + + @Test + public void sortTest() { + ArrayList cards = new ArrayList<>(); + CardComparator comp = new CardComparator(); + cards.add(new Card(1,Rank.ACE,Suit.DIAMOND)); + cards.add(new Card(1,Rank.ACE,Suit.SPADE)); + cards.add(new Card(1,Rank.SIX,Suit.HEART)); + cards.add(new Card(1,Rank.SIX,Suit.SPADE)); + cards.add(new Card(1,Rank.SIX,Suit.DIAMOND)); + cards.add(new Card(1,Rank.SIX,Suit.CLUB)); + + cards.sort(comp); + System.out.println(cards); + + + } +} \ No newline at end of file diff --git a/src/test/java/CardGameTest.java b/src/test/java/CardGameTest.java new file mode 100644 index 000000000..cbf024a09 --- /dev/null +++ b/src/test/java/CardGameTest.java @@ -0,0 +1,5 @@ +import static org.junit.Assert.*; + +public class CardGameTest { + +} \ No newline at end of file diff --git a/src/test/java/CardTest.java b/src/test/java/CardTest.java new file mode 100644 index 000000000..bc9de2552 --- /dev/null +++ b/src/test/java/CardTest.java @@ -0,0 +1,79 @@ + +import org.junit.Test; + + +import org.junit.Assert; + +public class CardTest { + + + @Test + public void flipTest1() { + Integer faceDownToEveryone = -1; + Card card = new Card(faceDownToEveryone, Rank.ACE, Suit.DIAMOND); + card.flip(); + Integer expected = 1; + Integer actual = card.getValue(); + Assert.assertTrue(card.isFaceUpToEveryone()); + Assert.assertEquals(expected, actual); + + } + @Test + public void flipTest2() { + Integer faceDown = 1; + Card card = new Card(faceDown, Rank.ACE, Suit.DIAMOND); + card.flip(); + Integer expected = 1; + Integer actual = card.getRankNumber(); + Assert.assertTrue(card.isFaceDownToEveryone()); + Assert.assertEquals(expected, actual); + } + @Test + public void flipTest3() { + Integer faceDown = 0; + Card card = new Card(faceDown, Rank.ACE, Suit.DIAMOND); + card.flip(); + Integer expected = 1; + Integer actual = card.getRankNumber(); + Assert.assertTrue(card.isFaceUpToEveryone()); + Assert.assertEquals(expected, actual); + } + + @Test + public void getValueTest1() { + Integer faceUp = 1; + Card card = new Card(faceUp, Rank.SIX, Suit.HEART); + + Integer expected = 6; + Integer actual = card.getValue(); + Assert.assertEquals(expected, actual); + } + + @Test + public void getValueTest2() { + Integer faceDown = -1; + Card card = new Card(faceDown, Rank.JACK, Suit.SPADE); + + Integer expected = 0; + Integer actual = card.getValue(); + Assert.assertEquals(expected, actual); + } + @Test + public void getValueTest3() { + Integer faceUpToMe = 0; + Card card = new Card(faceUpToMe, Rank.KING, Suit.CLUB); + + Integer expected = 0; + Integer actual = card.getValue(); + Assert.assertEquals(expected, actual); + } + @Test + public void getValueTest4() { + Integer faceUp = 1; + Card card = new Card(faceUp, Rank.QUEEN, Suit.HEART); + + Integer expected = 12; + Integer actual = card.getValue(); + Assert.assertEquals(expected, actual); + } +} \ No newline at end of file diff --git a/src/test/java/CeeLoPlayerTest.java b/src/test/java/CeeLoPlayerTest.java new file mode 100644 index 000000000..520f4ec9a --- /dev/null +++ b/src/test/java/CeeLoPlayerTest.java @@ -0,0 +1,5 @@ +import static org.junit.Assert.*; + +public class CeeLoPlayerTest { + +} \ No newline at end of file diff --git a/src/test/java/CeeLoTest.java b/src/test/java/CeeLoTest.java new file mode 100644 index 000000000..abb6f88bf --- /dev/null +++ b/src/test/java/CeeLoTest.java @@ -0,0 +1,30 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class CeeLoTest { + + @Test + public void takeTurn() { + } + + @Test + public void setNumber() { + } + + @Test + public void getNumberToBeat() { + } + + @Test + public void didWin() { + } + + @Test + public void playGame() { + } + + @Test + public void endOfGame() { + } +} \ No newline at end of file diff --git a/src/test/java/CeeLoTurnTest.java b/src/test/java/CeeLoTurnTest.java new file mode 100644 index 000000000..1f5502119 --- /dev/null +++ b/src/test/java/CeeLoTurnTest.java @@ -0,0 +1,26 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class CeeLoTurnTest { + + @Test + public void move() { + } + + @Test + public void roll() { + } + + @Test + public void compare() { + } + + @Test + public void checkWin() { + } + + @Test + public void validMove() { + } +} \ No newline at end of file diff --git a/src/test/java/DStyleCrapsPlayerTest.java b/src/test/java/DStyleCrapsPlayerTest.java new file mode 100644 index 000000000..136d8ab07 --- /dev/null +++ b/src/test/java/DStyleCrapsPlayerTest.java @@ -0,0 +1,47 @@ +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DStyleCrapsPlayerTest { + @Test + public void testChips() { + Dice dice = new Dice(2); + DStyleCrapsPlayer player1 = new DStyleCrapsPlayer(new Person(500.00, "Jon", 25)); + Chips chip=new Chips(player1.person.getWallet().doubleValue()); + Integer numchips=chip.getChips(); + Assert.assertEquals(100, numchips, 0.0001); + } + + @Test + public void testChips1() { + Dice dice = new Dice(2); + DStyleCrapsPlayer player1 = new DStyleCrapsPlayer(new Person(00.00, "Jon", 25)); + Chips chip=new Chips(0.00); + Integer numchips=chip.getChips(); + Assert.assertEquals(0, numchips, 0.0001); + } + + @Test + public void testRoll() { + Dice dice = new Dice(2); + DStyleCrapsPlayer player1 = new DStyleCrapsPlayer(new Person(500.00, "Jon", 25)); + Integer numroll = player1.roll(dice); + Boolean b = false; + if (numroll >= 12 || numroll <= 2) + b = false; + Assert.assertEquals(false, b); + } + + @Test + public void testBet() { + Dice dice=new Dice(2) ; + + DStyleCrapsPlayer[] player= {new DStyleCrapsPlayer(new Person(500.00,"Jon",25))}; + DolioStyleCraps dCraps = new DolioStyleCraps(player); + Integer totalChips=0; + //if( dc.didWin(player1)==true) + totalChips=player[0].bet(4); + Assert.assertEquals(4, totalChips,0.0001); + } +} diff --git a/src/test/java/DecksTest.java b/src/test/java/DecksTest.java new file mode 100644 index 000000000..d9373534e --- /dev/null +++ b/src/test/java/DecksTest.java @@ -0,0 +1,20 @@ +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DecksTest { + + + @Test + public void buildDeckTest() { + Decks deck = new Decks(3); + Assert.assertEquals(deck.getCards().size(), 3*52); + } + +// @Test +// public void buildSuitTest() { +// Decks deck = new Decks(1); +// deck.buil +// } +} \ No newline at end of file diff --git a/src/test/java/DiceTest.java b/src/test/java/DiceTest.java new file mode 100644 index 000000000..c510573d7 --- /dev/null +++ b/src/test/java/DiceTest.java @@ -0,0 +1,53 @@ +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DiceTest { + + @Test + public void tossAndSum() { + boolean b = false; + Dice dice = new Dice(2); + int j = dice.tossAndSum(); + if (j >= 2 && j <= 12) + b = true; + Assert.assertEquals(true, b); + } + + @Test + public void tossAndSum1() { + boolean b = false; + Dice dice = new Dice(2); + int j = dice.tossAndSum(); + if (j < 2 && j > 12) + b = false; + Assert.assertNotEquals(true, b); + } + + @Test + public void toss() { + boolean b = false; + Dice dice = new Dice(1); + Integer j = dice.toss(); + if (j >= 1 && j <= 6) + b = true; + Assert.assertEquals(true, b); + } + + @Test + public void toss1() { + boolean b = false; + Dice dice = new Dice(1); + Integer j = dice.toss(); + if (j < 1 && j > 6) + b = false; + Assert.assertEquals(false, b); + } +} + + + + diff --git a/src/test/java/DolioStyleCrapsTest.java b/src/test/java/DolioStyleCrapsTest.java new file mode 100644 index 000000000..746cad319 --- /dev/null +++ b/src/test/java/DolioStyleCrapsTest.java @@ -0,0 +1,62 @@ +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class DolioStyleCrapsTest { + + @Test + public void didWin() { + DStyleCrapsPlayer[] player = {new DStyleCrapsPlayer(new Person(500.00, "Jon", 25))}; + DolioStyleCraps dCraps = new DolioStyleCraps(player); + dCraps.playGame(); + System.out.println(dCraps.getDice().sum()); + System.out.println(dCraps.didWin(player[0])); + if (dCraps.getDice().sum() == 2) { + Assert.assertFalse(dCraps.didWin(player[0])); + } + } + + + @Test + public void didWin1() { + DStyleCrapsPlayer[] player = {new DStyleCrapsPlayer(new Person(500.00, "Jon", 25))}; + DolioStyleCraps dCraps = new DolioStyleCraps(player); + dCraps.playGame(); + if (dCraps.getDice().sum() != 11 || dCraps.getDice().sum() != 7||dCraps.getDice().sum() == 2) { + Assert.assertFalse(dCraps.didWin(player[0])); + } + } + @Test + public void didWin3() { + DStyleCrapsPlayer[] player = {new DStyleCrapsPlayer(new Person(500.00, "Jon", 25))}; + DolioStyleCraps dCraps = new DolioStyleCraps(player); + dCraps.playGame(); + if (dCraps.getDice().sum() == 11 || dCraps.getDice().sum() == 7) { + Assert.assertTrue(dCraps.didWin(player[0])); + } + } + @Test + public void playGame() { + DStyleCrapsPlayer[] player= {new DStyleCrapsPlayer(new Person(500.00,"Jon",25))}; + DolioStyleCraps dCraps = new DolioStyleCraps(player); + dCraps.playGame(); + if(dCraps.getDice().sum()!=0) + Assert.assertTrue(dCraps.getDice().sum()!=0); + } + + @Test + public void endOfGame() { + + DStyleCrapsPlayer[] player= {new DStyleCrapsPlayer(new Person(500.00,"Jon",25))}; + DolioStyleCraps dCraps=new DolioStyleCraps(player); + Boolean b = false; + dCraps.playGame(); + int j = dCraps.getDice().sum(); + if (j == 2) { + dCraps.didWin(player[0]); + } + Assert.assertEquals(false, dCraps.didWin(player[0])); + } + +} \ No newline at end of file diff --git a/src/test/java/GameTest.java b/src/test/java/GameTest.java new file mode 100644 index 000000000..937887130 --- /dev/null +++ b/src/test/java/GameTest.java @@ -0,0 +1,18 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class GameTest { + + @Test + public void didWin() { + } + + @Test + public void playGame() { + } + + @Test + public void endOfGame() { + } +} \ No newline at end of file diff --git a/src/test/java/HouseTest.java b/src/test/java/HouseTest.java new file mode 100644 index 000000000..2576ca351 --- /dev/null +++ b/src/test/java/HouseTest.java @@ -0,0 +1,70 @@ +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class HouseTest { + + @Test + public void payoutTest() { + Decks decks = new Decks(1); + House house = new House(2, decks); + house.takeBets(2); + Integer expected = 4; + Integer actual = house.payout(2); + Assert.assertEquals(expected, actual); + } + + @Test + public void takeBetsTest() { + Decks decks = new Decks(1); + House house = new House(2, decks); + house.takeBets(1, 2); + Integer expected = 6; + Integer actual = house.getHouseWallet(); + Assert.assertEquals(expected, actual); + } + + @Test + public void moneyToChipsTest1() { + Decks decks = new Decks(1); + House house = new House(2, decks); + Integer expected = 20; + Integer actual = house.moneyToChips(100.0); + Assert.assertEquals(expected, actual); + } + @Test + public void moneyToChipsTest2() { + Decks decks = new Decks(1); + House house = new House(2, decks); + Integer expected = 20; + Integer actual = house.moneyToChips(103.43); + Assert.assertEquals(expected, actual); + } + + @Test + public void shuffleTest() { + Decks decks = new Decks(1); + House house = new House(2, decks); + Card firstCard = decks.getCards().get(0); + Card secondCard = decks.getCards().get(1); + Card thirdCard = decks.getCards().get(2); + house.shuffle(); + decks = house.getDecks(); + if (!firstCard.equals(decks.getCards().get(0))) return; + if (!secondCard.equals(decks.getCards().get(1))) return; + if (!thirdCard.equals(decks.getCards().get(2))) return; + assertNull(decks); + } + + + @Test + public void dealCardTest() { + Decks decks = new Decks(1); + House house = new House(2, decks); + Card card = house.dealCard(); + assertNotEquals(decks.getCards().size(), 52); + assertNotNull(card); + + } +} \ No newline at end of file diff --git a/src/test/java/LoungeTest.java b/src/test/java/LoungeTest.java new file mode 100644 index 000000000..fee4f14e7 --- /dev/null +++ b/src/test/java/LoungeTest.java @@ -0,0 +1,10 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class LoungeTest { + + @Test + public void chooseGame() { + } +} \ No newline at end of file diff --git a/src/test/java/MediatorTest.java b/src/test/java/MediatorTest.java new file mode 100644 index 000000000..95b9bdc6e --- /dev/null +++ b/src/test/java/MediatorTest.java @@ -0,0 +1,20 @@ +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class MediatorTest { + + @Test + public void enterLounge() { + } + + @Test + public void parseInput() { + } + + @Test + public void checkAge() { + + } +} \ No newline at end of file diff --git a/src/test/java/PalaceHandTest.java b/src/test/java/PalaceHandTest.java new file mode 100644 index 000000000..4bb491a8d --- /dev/null +++ b/src/test/java/PalaceHandTest.java @@ -0,0 +1,5 @@ +import static org.junit.Assert.*; + +public class PalaceHandTest { + +} \ No newline at end of file diff --git a/src/test/java/PalacePlayerTest.java b/src/test/java/PalacePlayerTest.java new file mode 100644 index 000000000..b00552dc7 --- /dev/null +++ b/src/test/java/PalacePlayerTest.java @@ -0,0 +1,5 @@ +import static org.junit.Assert.*; + +public class PalacePlayerTest { + +} \ No newline at end of file diff --git a/src/test/java/PalaceTest.java b/src/test/java/PalaceTest.java new file mode 100644 index 000000000..f493c6ad2 --- /dev/null +++ b/src/test/java/PalaceTest.java @@ -0,0 +1,18 @@ +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PalaceTest { + + @Test + public void didWin() { + } + + @Test + public void playGame() { + } + + @Test + public void endOfGame() { + } +} \ No newline at end of file diff --git a/src/test/java/PalaceTurnTest.java b/src/test/java/PalaceTurnTest.java new file mode 100644 index 000000000..89ab03788 --- /dev/null +++ b/src/test/java/PalaceTurnTest.java @@ -0,0 +1,20 @@ +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PalaceTurnTest { + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void validMove() { + } +} \ No newline at end of file diff --git a/src/test/java/PersonTest.java b/src/test/java/PersonTest.java new file mode 100644 index 000000000..14bc63d28 --- /dev/null +++ b/src/test/java/PersonTest.java @@ -0,0 +1,23 @@ +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PersonTest { + @Test + public void constructorTest() { + Integer age = 21; + Double wallet = 100.0; + String name = "Foo"; + Person p = new Person(wallet, name, age); + assertNotNull(p); + Integer actualAge = p.getAge(); + assertEquals(age, actualAge); + Double actualWallet = 100.0; + assertEquals(wallet, actualWallet); + String actualName = p.getName(); + assertEquals(name, actualName); + } +} \ No newline at end of file diff --git a/src/test/java/PileOfCardsTest.java b/src/test/java/PileOfCardsTest.java new file mode 100644 index 000000000..ced0fee11 --- /dev/null +++ b/src/test/java/PileOfCardsTest.java @@ -0,0 +1,69 @@ +import org.junit.Test; + +import java.util.ArrayList; + +import static org.junit.Assert.*; + +public class PileOfCardsTest { + + @Test + public void clearTest() { + PileOfCards pile = new PileOfCards(); + ArrayList cards = new ArrayList<>(5); + cards.add(new Card(-1, Rank.ACE, Suit.CLUB)); + cards.add(new Card(-1, Rank.TWO, Suit.CLUB)); + cards.add(new Card(-1, Rank.THREE, Suit.CLUB)); + pile.addAll(cards); + } + + @Test + public void addAllTest() { + PileOfCards pile = new PileOfCards(); + ArrayList cards = new ArrayList<>(5); + cards.add(new Card(-1, Rank.ACE, Suit.CLUB)); + cards.add(new Card(-1, Rank.TWO, Suit.CLUB)); + cards.add(new Card(-1, Rank.THREE, Suit.CLUB)); + pile.addAll(cards); + assertFalse(pile.getCards().empty()); + } + + @Test + public void addTest() { + PileOfCards pile = new PileOfCards(); + ArrayList cards = new ArrayList<>(5); + pile.add(new Card(-1, Rank.JACK, Suit.DIAMOND)); + assertFalse(pile.getCards().empty()); + } + + @Test + public void removeTest1() { + PileOfCards pile = new PileOfCards(); + Card card = new Card(-1, Rank.JACK, Suit.DIAMOND); + pile.add(card); + assertNotNull(pile.remove()); + assertTrue(pile.getCards().empty()); + } + @Test + public void removeTest2() { + PileOfCards pile = new PileOfCards(); + ArrayList cards = new ArrayList<>(5); + cards.add(new Card(-1, Rank.ACE, Suit.CLUB)); + cards.add(new Card(-1, Rank.TWO, Suit.CLUB)); + cards.add(new Card(-1, Rank.THREE, Suit.CLUB)); + pile.addAll(cards); + assertFalse(pile.getCards().empty()); + pile.remove(); + pile.remove(); + pile.remove(); + assertTrue(pile.getCards().empty()); + } + @Test + public void removeTest3() { + PileOfCards pile = new PileOfCards(); + Card card = new Card(-1, Rank.JACK, Suit.DIAMOND); + pile.add(card); + pile.remove(); + assertNull(pile.remove()); + assertTrue(pile.getCards().empty()); + } +} \ No newline at end of file diff --git a/src/test/java/PlayerTest.java b/src/test/java/PlayerTest.java new file mode 100644 index 000000000..26a929048 --- /dev/null +++ b/src/test/java/PlayerTest.java @@ -0,0 +1,15 @@ +import org.junit.After; +import org.junit.Before; + +import static org.junit.Assert.*; + +public class PlayerTest { + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } +} \ No newline at end of file diff --git a/src/test/java/PokerHandEvaluatorTest.java b/src/test/java/PokerHandEvaluatorTest.java new file mode 100644 index 000000000..2a3ae1862 --- /dev/null +++ b/src/test/java/PokerHandEvaluatorTest.java @@ -0,0 +1,11 @@ +import org.junit.Assert; +import org.junit.Test; + +public class PokerHandEvaluatorTest { + + @Test + public void flushTest() + { + // Assert.assertEquals(PokerHandEvaluator.ROYAL_FLUSH, PokerHandEvaluator.determineHand()); + } +} diff --git a/src/test/java/PokerHandTest.java b/src/test/java/PokerHandTest.java new file mode 100644 index 000000000..dffc37038 --- /dev/null +++ b/src/test/java/PokerHandTest.java @@ -0,0 +1,27 @@ +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PokerHandTest { + PokerHand pokerHand; + @Before + public void setUp() + { +// pokerHand = new PokerHand(); + } + @Test + public void pokerHandSizeTest() { +// PokerHand pokerHand = new PokerHand(); + Assert.assertEquals(2, (int) pokerHand.numberOfCardsInHand()); + } + + @Test + public void pokerUniqueTest() { + // assuming only 1 deck + // PokerHand pokerHand = new PokerHand(); + // Assert.assertNotEquals(pokerHand.getCards().get(0),pokerHand.getCards().get(1)); + } +} \ No newline at end of file diff --git a/src/test/java/PokerPlayerTest.java b/src/test/java/PokerPlayerTest.java new file mode 100644 index 000000000..0849928f6 --- /dev/null +++ b/src/test/java/PokerPlayerTest.java @@ -0,0 +1,139 @@ +import exceptions.NegativeBetException; +import exceptions.NotEnoughChipException; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PokerPlayerTest { + PokerPlayer player; + Integer originalChips; + + @Before + public void setUp() throws Exception { + player = new PokerPlayer(new Person(100.0,"John", 21)); + player.setChips(100); + originalChips = player.getChip(); + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void leaveGame() { + } + + @Test + public void callTest() { + Assert.assertEquals(10, (int) player.call(10)); + } + + @Test + public void callChipTest() { + Integer lastPlayerBet = 10; + Integer expected = originalChips-lastPlayerBet; + player.call(lastPlayerBet); + Assert.assertEquals(expected,player.getChip()); + } + + @Test + public void checkTestChip() { + Assert.assertEquals(originalChips,player.getChip()); + } + + @Test + public void checkTest() { + Assert.assertEquals(0, (int) player.check()); + } + + @Test + public void fold() { + player.fold(); + Assert.assertTrue(player.isFolded()); + } + + @Test + public void NotFold() { + Assert.assertFalse(player.isFolded()); + } + + @Test + public void raise1() { + Assert.assertEquals(30, (int) player.raise(10,20)); + } + + @Test + public void raiseAfterCheck() { + Assert.assertEquals(2, (int) player.raise(0,2)); + } + + @Test + public void raise2() { + Assert.assertEquals(50, (int) player.raise(30,20)); + } + + @Test + public void raiseChip() { + Integer expected = originalChips-50; + player.raise(30,20); + Assert.assertEquals(expected, player.getChip()); + } + + @Test (expected = NegativeBetException.class) + public void raiseNegative() { + player.raise(30,-20); + } + + + @Test + public void smallBlind() { + Assert.assertEquals(1, (int) player.smallBlind()); + } + + @Test + public void bigBlind() { + Assert.assertEquals(2, (int) player.bigBlind()); + } + + + @Test + public void smallBlindChip() { + Integer expected = originalChips-1; + player.smallBlind(); + Assert.assertEquals(expected, player.getChip()); + } + + @Test + public void bigBlindChip() { + Integer expected = originalChips-2; + player.bigBlind(); + Assert.assertEquals(expected, player.getChip()); + } + + @Test + public void betTest() { + Assert.assertEquals(30, (int) player.bet(30)); + } + + @Test + public void betTestChip() { + Integer bet = 50; + Integer expected = originalChips-bet; + player.bet(bet); + Assert.assertEquals(expected,player.getChip()); + } + + @Test (expected = NegativeBetException.class) + public void betTestNegative() { + player.bet(-10); + } + + @Test (expected = NotEnoughChipException.class) + public void betTestNotEnoughChip() { + player.bet(110); + + } +} \ No newline at end of file diff --git a/src/test/java/PokerTest.java b/src/test/java/PokerTest.java new file mode 100644 index 000000000..92c5ee313 --- /dev/null +++ b/src/test/java/PokerTest.java @@ -0,0 +1,28 @@ +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PokerTest { + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void didWin() { + } + + @Test + public void playGame() { + } + + @Test + public void endOfGame() { + } +} \ No newline at end of file diff --git a/src/test/java/PokerTurnTest.java b/src/test/java/PokerTurnTest.java new file mode 100644 index 000000000..5e21251a7 --- /dev/null +++ b/src/test/java/PokerTurnTest.java @@ -0,0 +1,20 @@ +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PokerTurnTest { + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void validMove() { + } +} \ No newline at end of file diff --git a/src/test/java/PrasanthiPalaceTest.java b/src/test/java/PrasanthiPalaceTest.java new file mode 100644 index 000000000..4082661a5 --- /dev/null +++ b/src/test/java/PrasanthiPalaceTest.java @@ -0,0 +1,24 @@ +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class PrasanthiPalaceTest { + + @Before + public void setUp() throws Exception { + } + + @After + public void tearDown() throws Exception { + } + + @Test + public void main() { + } + + @Test + public void run() { + } +} \ No newline at end of file