Dimas branch

.gitignore

@@ -560,3 +560,6 @@ healthchecksdb
 MigrationBackup/
 
 # End of https://www.gitignore.io/api/eclipse,intellij,netbeans,notepadpp,sublimetext,visualstudio
+
+# need to ignore
+.DS_Store

src/main/java/com/github/zipcodewilmington/Casino.java

@@ -31,9 +31,9 @@ public void run() {
                 if (isValidLogin) {
                     String gameSelectionInput = getGameSelectionInput().toUpperCase();
                     if (gameSelectionInput.equals("SLOTS")) {
-                        play(new SlotsGame(), new SlotsPlayer());
+                        play(new SlotsGame(), new SlotsPlayer(casinoAccount,console));
                     } else if (gameSelectionInput.equals("NUMBERGUESS")) {
-                        play(new NumberGuessGame(), new NumberGuessPlayer());
+                        play(new NumberGuessGame(), new NumberGuessPlayer(casinoAccount, console));
                     } else {
                         // TODO - implement better exception handling
                         String errorMessage = "[ %s ] is an invalid game selection";

src/main/java/com/github/zipcodewilmington/casino/CardGame.java

@@ -0,0 +1,49 @@
+package com.github.zipcodewilmington.casino;
+
+import com.github.zipcodewilmington.casino.cardutils.TheDeck;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public abstract class CardGame implements GameInterface{
+    ArrayList<CardPlayer> players;
+    TheDeck theDeck;
+    HashMap<CardPlayer, Integer> playerScores;
+
+    // Constructors
+    public CardGame() {
+        players = new ArrayList<>();
+        theDeck = new TheDeck();
+        playerScores = new HashMap<>();
+    }
+
+    public TheDeck getTheDeck() {
+        return theDeck;
+    }
+
+    public ArrayList<CardPlayer> getPlayers() {
+        return players;
+    }
+
+    @Override
+    public void add(PlayerInterface player) {
+        players.add((CardPlayer) player);
+        playerScores.put((CardPlayer) player, 0);
+    }
+
+    @Override
+    public void remove(PlayerInterface player) {
+        players.remove((CardPlayer) player);
+        playerScores.remove((CardPlayer) player);
+    }
+
+    public void dealCards(int cardsForEach){
+        for(int i = 0; i < cardsForEach; i++){
+            // each round of dealing
+            for(CardPlayer cp : players){
+                // for each player, give one card
+                cp.receiveCard(theDeck.drawCard());
+            }
+        }
+    }
+}

src/main/java/com/github/zipcodewilmington/casino/CardPlayer.java

@@ -0,0 +1,83 @@
+package com.github.zipcodewilmington.casino;
+
+import com.github.zipcodewilmington.casino.cardutils.*;
+import com.github.zipcodewilmington.utils.IOConsole;
+
+import java.util.Scanner;
+
+public abstract class CardPlayer extends PlayerClass{
+    HandOfCards curHand;
+
+    // Constructor
+    public CardPlayer(CasinoAccount wallet, IOConsole console){
+        super(wallet, console);
+        curHand = new HandOfCards();
+    }
+    public CardPlayer(HandOfCards hand){
+        super(null, null);
+        curHand = hand;
+    }
+
+    // my other functions
+    public HandOfCards getHandOfCards(){
+        return curHand;
+    }
+
+    public void receiveCard(PlayingCard pc){
+        curHand.addCard(pc);
+    }
+
+    public void useCard(PlayingCard pc){
+        curHand.removeCard(pc);
+    }
+
+    public void printHand(){
+        // not sure what to put here yet so i'll leave it empty for now
+        super.printToConsole(curHand.toString());
+    }
+
+    public void clearHand(){
+        curHand.clear();
+    }
+
+    public PlayingCard promptForCard(String prompt){
+        String response = super.promptPlayerForChoice(prompt);
+        String[] cardPieces = response.toUpperCase().split(" ");
+
+        PlayingCardValue pcv = parseCardValue(cardPieces);
+        PlayingCardSuit pcs = parseCardSuit(cardPieces);
+
+        if(pcv == null || pcs == null){
+            // or some exception??? dunno yet
+            return null;
+        }
+        return new PlayingCard(pcs, pcv);
+    }
+
+    private PlayingCardSuit parseCardSuit(String[] cardPieces) {
+        for(String s : cardPieces){
+            // iterating through the stuff split into spaces
+            for(PlayingCardSuit suit : PlayingCardSuit.values()){
+                if(s.equals(suit.name())){
+                    return suit;
+                }
+            }
+        }
+        return null;
+    }
+
+    private PlayingCardValue parseCardValue(String[] cardPieces) {
+        for(String s : cardPieces){
+            // iterating through the stuff split into spaces
+            for(PlayingCardValue value : PlayingCardValue.values()){
+                if(s.equals(value.toString())){
+                    return value;
+                }
+            }
+        }
+        return null;
+    }
+
+    // abstract functions here
+    public abstract void sortHand();
+}

src/main/java/com/github/zipcodewilmington/casino/CasinoAccount.java

@@ -6,4 +6,34 @@
  * The `ArcadeAccount` is used to log into the system to select a `Game` to play.
  */
 public class CasinoAccount {
-}
+
+    private String accOwner;
+    private String accPassword;
+    private int accBalance;
+
+    public CasinoAccount(String accOwner, String accPassword, int accBalance){
+        this.accOwner = accOwner;
+        this.accPassword = accPassword;
+        this.accBalance = accBalance;
+    }
+
+    public int getAccBalance() {return this.accBalance;}
+
+    public void setAccBalance(int accBalance) {
+        this.accBalance = accBalance;
+    }
+
+    public String getAccOwner() {return this.accOwner;}
+
+    public void updateAccBalance(int winnings) {
+        this.accBalance = this.accBalance + winnings;
+    }
+
+    public String getAccPassword() {
+        return accPassword;
+    }
+
+    public void setAccPassword(String accPassword) {
+        this.accPassword = accPassword;
+    }
+}

src/main/java/com/github/zipcodewilmington/casino/CasinoAccountManager.java

@@ -1,21 +1,36 @@
 package com.github.zipcodewilmington.casino;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+
 /**
  * Created by leon on 7/21/2020.
  * `ArcadeAccountManager` stores, manages, and retrieves `ArcadeAccount` objects
  * it is advised that every instruction in this class is logged
  */
 public class CasinoAccountManager {
+    HashMap<String, CasinoAccount> listOfAccounts = new HashMap<>();
+    public HashMap<String, CasinoAccount> getListOfAccounts() {
+        return listOfAccounts;
+    }
+
     /**
      * @param accountName     name of account to be returned
      * @param accountPassword password of account to be returned
      * @return `ArcadeAccount` with specified `accountName` and `accountPassword`
      */
     public CasinoAccount getAccount(String accountName, String accountPassword) {
-        String currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName();
-        String currentClassName = getClass().getName();
-        String errorMessage = "Method with name [ %s ], defined in class with name [ %s ] has  not yet been implemented";
-        throw new RuntimeException(String.format(errorMessage, currentMethodName, currentClassName));
+//        String currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName();
+//        String currentClassName = getClass().getName();
+//        String errorMessage = "Method with name [ %s ], defined in class with name [ %s ] has  not yet been implemented";
+//        throw new RuntimeException(String.format(errorMessage, currentMethodName, currentClassName));
+        if(listOfAccounts.containsKey(accountName)){
+            if(listOfAccounts.get(accountName).getAccPassword().equals(accountPassword)){
+                return listOfAccounts.get(accountName);
+            }
+        }
+        String errorMessage = "There is no account with this name and password!";
+        throw new RuntimeException(errorMessage);
     }
 
     /**
@@ -26,10 +41,13 @@ public CasinoAccount getAccount(String accountName, String accountPassword) {
      * @return new instance of `ArcadeAccount` with specified `accountName` and `accountPassword`
      */
     public CasinoAccount createAccount(String accountName, String accountPassword) {
-        String currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName();
-        String currentClassName = getClass().getName();
-        String errorMessage = "Method with name [ %s ], defined in class with name [ %s ] has  not yet been implemented";
-        throw new RuntimeException(String.format(errorMessage, currentMethodName, currentClassName));
+//        String currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName();
+//        String currentClassName = getClass().getName();
+//        String errorMessage = "Method with name [ %s ], defined in class with name [ %s ] has  not yet been implemented";
+//        throw new RuntimeException(String.format(errorMessage, currentMethodName, currentClassName));
+        CasinoAccount ca = new CasinoAccount(accountName, accountPassword, 1_000);
+        listOfAccounts.put(accountName, ca);
+        return ca;
     }
 
     /**
@@ -38,9 +56,10 @@ public CasinoAccount createAccount(String accountName, String accountPassword) {
      * @param casinoAccount the arcadeAccount to be added to `this.getArcadeAccountList()`
      */
     public void registerAccount(CasinoAccount casinoAccount) {
-        String currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName();
-        String currentClassName = getClass().getName();
-        String errorMessage = "Method with name [ %s ], defined in class with name [ %s ] has  not yet been implemented";
-        throw new RuntimeException(String.format(errorMessage, currentMethodName, currentClassName));
+//        String currentMethodName = new Object(){}.getClass().getEnclosingMethod().getName();
+//        String currentClassName = getClass().getName();
+//        String errorMessage = "Method with name [ %s ], defined in class with name [ %s ] has  not yet been implemented";
+//        throw new RuntimeException(String.format(errorMessage, currentMethodName, currentClassName));
+        listOfAccounts.put(casinoAccount.getAccOwner(), casinoAccount);
     }
 }

src/main/java/com/github/zipcodewilmington/casino/GambleGameInterface.java

@@ -0,0 +1,6 @@
+package com.github.zipcodewilmington.casino;
+
+public interface GambleGameInterface {
+
+    int payOutCalc(int betAmount, int payOutMult);
+}

src/main/java/com/github/zipcodewilmington/casino/GamblerInterface.java

@@ -0,0 +1,13 @@
+package com.github.zipcodewilmington.casino;
+
+public interface GamblerInterface {
+
+    int makeBet(int bet);
+
+    boolean validBet(int bet);
+
+    //The winnings from a bet going into the player's wallet
+    void depositPayOut(int winnings);
+
+
+}

src/main/java/com/github/zipcodewilmington/casino/GameInterface.java

@@ -20,4 +20,8 @@ public interface GameInterface extends Runnable {
      * specifies how the game will run
      */
     void run();
+
+    void printWinner();
+
+    boolean isEndCondition();
 }

src/main/java/com/github/zipcodewilmington/casino/HouseAccount.java

@@ -0,0 +1,33 @@
+package com.github.zipcodewilmington.casino;
+
+public class HouseAccount {
+
+    private static HouseAccount houseAccount;
+    private int accBalance;
+
+    private HouseAccount() {
+        accBalance = 1_000_000;
+    }
+
+    public static synchronized HouseAccount getHouseAccount()  {
+        if (houseAccount == null) {
+            houseAccount = new HouseAccount();
+        }
+        return houseAccount;
+    }
+
+    public int getBalance() {
+        return this.accBalance;}
+
+    public int payout(int losses) {
+        //Casino is losing money
+        this.accBalance = accBalance - losses;
+        return losses;
+    }
+
+    public void acceptMoney(int winnings) {
+        //Casino is gaining money
+        this.accBalance = accBalance + winnings;
+    }
+
+}