Feature/dipinti test files

README.md

@@ -73,3 +73,8 @@
 * from the browser, navigate to the _forked_ project from **your** github account.
 * click the `Pull Requests` tab.
 * select `New Pull Request`
+
+
+
+
+## Adding a line to the readMe for git hub example

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

@@ -1,22 +1,27 @@
 package com.github.zipcodewilmington;
 
-import com.github.zipcodewilmington.casino.CasinoAccount;
-import com.github.zipcodewilmington.casino.CasinoAccountManager;
-import com.github.zipcodewilmington.casino.GameInterface;
-import com.github.zipcodewilmington.casino.PlayerInterface;
+import com.github.zipcodewilmington.casino.*;
+import com.github.zipcodewilmington.casino.games.Beetle.BeetleGame;
+import com.github.zipcodewilmington.casino.games.blackjack.BlackJackGame;
 import com.github.zipcodewilmington.casino.games.numberguess.NumberGuessGame;
 import com.github.zipcodewilmington.casino.games.numberguess.NumberGuessPlayer;
+import com.github.zipcodewilmington.casino.games.plinko.PlinkoGame;
 import com.github.zipcodewilmington.casino.games.slots.SlotsGame;
 import com.github.zipcodewilmington.casino.games.slots.SlotsPlayer;
 import com.github.zipcodewilmington.utils.AnsiColor;
+import com.github.zipcodewilmington.utils.CSVUtils;
 import com.github.zipcodewilmington.utils.IOConsole;
 
+import java.io.IOException;
+import java.util.Locale;
+
 /**
  * Created by leon on 7/21/2020.
  */
 public class Casino implements Runnable {
     private final IOConsole console = new IOConsole(AnsiColor.BLUE);
-
+    private CasinoAccount casinoAccount;
+    private PlayerInterface player;
     @Override
     public void run() {
         String arcadeDashBoardInput;
@@ -29,27 +34,36 @@ public void run() {
                 CasinoAccount casinoAccount = casinoAccountManager.getAccount(accountName, accountPassword);
                 boolean isValidLogin = casinoAccount != null;
                 if (isValidLogin) {
+
+
                     String gameSelectionInput = getGameSelectionInput().toUpperCase();
-                    if (gameSelectionInput.equals("SLOTS")) {
-                        play(new SlotsGame(), new SlotsPlayer());
-                    } else if (gameSelectionInput.equals("NUMBERGUESS")) {
-                        play(new NumberGuessGame(), new NumberGuessPlayer());
-                    } else {
-                        // TODO - implement better exception handling
-                        String errorMessage = "[ %s ] is an invalid game selection";
-                        throw new RuntimeException(String.format(errorMessage, gameSelectionInput));
-                    }
+                    processGameSelection(gameSelectionInput);
                 } else {
                     // TODO - implement better exception handling
                     String errorMessage = "No account found with name of [ %s ] and password of [ %s ]";
-                    throw new RuntimeException(String.format(errorMessage, accountPassword, accountName));
+                    //throw new RuntimeException(String.format(errorMessage, accountPassword, accountName));
                 }
             } else if ("create-account".equals(arcadeDashBoardInput)) {
                 console.println("Welcome to the account-creation screen.");
                 String accountName = console.getStringInput("Enter your account name:");
                 String accountPassword = console.getStringInput("Enter your account password:");
                 CasinoAccount newAccount = casinoAccountManager.createAccount(accountName, accountPassword);
                 casinoAccountManager.registerAccount(newAccount);
+                this.casinoAccount = newAccount;
+                casinoAccount.alterAccountBalance(500);
+                this.player = new Player(accountName, casinoAccount);
+                this.player.setArcadeAccount(casinoAccount);
+            } else if("save-account".equals(arcadeDashBoardInput)){
+                try {
+                    CSVUtils.csvFileSaver(this.player.getArcadeAccount());
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    console.println("Save unsuccessful, refer to error message above for more information");
+                }
+            } else if("load-saved-account".equals(arcadeDashBoardInput)){
+                this.casinoAccount = CSVUtils.loadData();
+                this.player = new Player(this.casinoAccount.getAccountName(), this.casinoAccount);
+                casinoAccountManager.registerAccount(this.casinoAccount);
             }
         } while (!"logout".equals(arcadeDashBoardInput));
     }
@@ -58,18 +72,42 @@ private String getArcadeDashboardInput() {
         return console.getStringInput(new StringBuilder()
                 .append("Welcome to the Arcade Dashboard!")
                 .append("\nFrom here, you can select any of the following options:")
-                .append("\n\t[ create-account ], [ select-game ]")
+                .append("\n\t[ create-account ], [ select-game ], [ load-saved-account ], [ save-account ]")
                 .toString());
     }
 
     private String getGameSelectionInput() {
         return console.getStringInput(new StringBuilder()
                 .append("Welcome to the Game Selection Dashboard!")
                 .append("\nFrom here, you can select any of the following options:")
-                .append("\n\t[ SLOTS ], [ NUMBERGUESS ]")
+                .append("\n\t[ SLOTS ], [ NUMBERGUESS ], [ PLINKO ], [ BEETLE ], [ BLACKJACK ]" +
+                        "[ KENO ]")
                 .toString());
     }
 
+    private void processGameSelection(String input){
+        input = input.toLowerCase(Locale.ROOT);
+        GameInterface gameObject;
+        switch(input){
+            case "beetle":
+                gameObject = new BeetleGame();
+                break;
+            case "slots":
+                gameObject = new SlotsGame();
+                break;
+            case "blackjack":
+                gameObject = new BlackJackGame();
+                break;
+            case "numberguess":
+                gameObject = new NumberGuessGame();
+                break;
+            default:
+                gameObject = new BeetleGame();
+        }
+
+        play(gameObject, player);
+    }
+
     private void play(Object gameObject, Object playerObject) {
         GameInterface game = (GameInterface)gameObject;
         PlayerInterface player = (PlayerInterface)playerObject;

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

@@ -1,7 +1,12 @@
 package com.github.zipcodewilmington;
 
+import com.github.zipcodewilmington.casino.games.slots.SlotsGame;
+
 public class MainApplication {
     public static void main(String[] args) {
         new Casino().run();
+
+//        SlotsGame slotGame = new SlotsGame();
+//        slotGame.run();
     }
 }

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

@@ -1,9 +1,38 @@
 package com.github.zipcodewilmington.casino;
 
+import com.github.zipcodewilmington.Casino;
+
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Created by leon on 7/21/2020.
  * `ArcadeAccount` is registered for each user of the `Arcade`.
  * The `ArcadeAccount` is used to log into the system to select a `Game` to play.
  */
 public class CasinoAccount {
+    private String password;
+    private String accountName;
+    private Integer accountBalance = 0;
+
+    public CasinoAccount(String accountName, String accountPassword){
+        this.accountName = accountName;
+        this.password = accountPassword;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getAccountName() {
+        return accountName;
+    }
+
+    public Integer getAccountBalance() {
+        return accountBalance;
+    }
+
+    public void alterAccountBalance(Integer value) {
+        this.accountBalance += value;
+    }
 }

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

@@ -1,17 +1,33 @@
 package com.github.zipcodewilmington.casino;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * 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 {
+    private List<CasinoAccount> accountList = new ArrayList<CasinoAccount>();
     /**
      * @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) {
+        for(int i = 0; i < accountList.size(); i++){
+            CasinoAccount currentAccount = accountList.get(i);
+            String pass = currentAccount.getPassword();
+            String name = currentAccount.getAccountName();
+            if(name.equals(accountName))
+               if(pass.equals(accountPassword)){
+                   return currentAccount;
+            } else {
+                System.out.println("Account Name or Password does not match. Are you really you?");
+                return null;
+            }
+        }
         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";
@@ -26,10 +42,12 @@ 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));
+        CasinoAccount myAccount = new CasinoAccount(accountName, accountPassword);
+        return myAccount;
+        //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));
     }
 
     /**
@@ -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));
+        this.accountList.add(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));
     }
 }

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

@@ -1,7 +1,8 @@
 package com.github.zipcodewilmington.casino;
 
 /**
- * Created by leon on 7/21/2020.
+ * Author: Nathan
+ * Date: 7/12/21
  */
 public interface GameInterface extends Runnable {
     /**
@@ -20,4 +21,23 @@ public interface GameInterface extends Runnable {
      * specifies how the game will run
      */
     void run();
+
+    /**
+     * Calculate player's winning payout amount of bet x multiplier
+     * @return (double) amount of money winnings
+     */
+    Integer calculateWinnings(Integer multiplier, Integer betAmount);
+
+    /**
+     * Subtract the bet amount from player's balance
+     */
+    void subtractBetFromBalance(Integer betAmount);
+
+    /**
+     * Add winnings amount to player's balance
+     */
+    void addMoneyToBalance(PlayerInterface Player, Integer winnings);
+
+
+
 }

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

@@ -0,0 +1,51 @@
+package com.github.zipcodewilmington.casino;
+
+
+public class Player implements PlayerInterface{
+
+    String name;
+    Integer balance;
+    Integer currentBet = 0;
+    CasinoAccount arcadeAccount;
+
+    public Player(String name, CasinoAccount account) {
+        this.name = name;
+        this.arcadeAccount = account;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+
+    public Integer getBalance() {
+        return balance;
+    }
+
+    public void setCurrentBet(Integer currentBet) {
+        this.currentBet = currentBet;
+    }
+
+    public void setBalance(Integer deposit) {
+        this.balance = balance + deposit;
+    }
+
+
+    public Integer makeBet(Integer betAmount) {
+        currentBet = betAmount;
+        balance = balance - currentBet;
+        return currentBet;
+    }
+
+    public Integer getCurrentBet() {
+        return currentBet;
+    }
+
+    public CasinoAccount getArcadeAccount(){
+        return this.arcadeAccount;
+    }
+
+    public void setArcadeAccount(CasinoAccount arcadeAccount) {
+        this.arcadeAccount = arcadeAccount;
+    }
+}

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

@@ -11,11 +11,13 @@ public interface PlayerInterface {
      * @return the `ArcadeAccount` used to log into the `Arcade` system to play this game
      */
     CasinoAccount getArcadeAccount();
-
+    void setArcadeAccount(CasinoAccount casinoAccount);
     /**
      * Defines how a specific implementation of `PlayerInterface` plays their respective game.
      * @param <SomeReturnType> specify any return type you would like here
      * @return whatever return value you would like
      */
-    <SomeReturnType> SomeReturnType play();
+
+
+    //<SomeReturnType> SomeReturnType play();
 }