Feat/plinko

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

@@ -42,7 +42,7 @@ public void run() {
                 } 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.");

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

@@ -1,9 +1,32 @@
 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;
+
+
+    public CasinoAccount(String accountName, String accountPassword){
+        this.accountName = accountName;
+        this.password = accountPassword;
+    }
+
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getAccountName() {
+        return accountName;
+    }
+
 }

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,21 @@ 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,42 @@
+package com.github.zipcodewilmington.casino;
+
+public class Player{
+
+    String name;
+    Integer balance;
+    Integer currentBet = 0;
+
+    public Player(String name, Integer initialDeposit) {
+        this.name = name;
+        this.balance = initialDeposit;
+    }
+
+
+    public String getName() {
+        return name;
+    }
+
+
+    public Integer getBalance() {
+        return balance;
+    }
+
+    private 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;
+    }
+
+    private Integer getCurrentBet() {
+        return currentBet;
+    }
+}

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

@@ -17,5 +17,5 @@ public interface PlayerInterface {
      * @param <SomeReturnType> specify any return type you would like here
      * @return whatever return value you would like
      */
-    <SomeReturnType> SomeReturnType play();
+    //<SomeReturnType> SomeReturnType play();
 }

src/main/java/com/github/zipcodewilmington/casino/games/Beetle/Beetle.java

@@ -0,0 +1,96 @@
+package com.github.zipcodewilmington.casino.games.Beetle;
+
+import com.github.zipcodewilmington.casino.models.Dice;
+
+public class Beetle{
+    private Dice dice = new Dice(1);
+    private Integer currentPlayer = 0;
+    private Integer[][] playerBeetles;
+    private Integer[] scoreboard;
+    private Integer numPlayers;
+
+    public Beetle(Integer numPlayers){
+        this.numPlayers = numPlayers;
+        this.playerBeetles = new Integer[numPlayers][6];
+        this.scoreboard = new Integer[numPlayers];
+        this.initializeBeetleCards();
+        this.initializeScoreboards();
+    }
+
+    public void initializeBeetleCards(){
+        for(int i = 0; i < numPlayers; i++){
+            for(int j = 0; j < 6; j++){
+                this.playerBeetles[i][j] = 0;
+            }
+        }
+    }
+
+    public void initializeScoreboards(){
+        for(int i = 0; i < numPlayers; i++){
+            this.scoreboard[i] = 0;
+        }
+    }
+
+    public Dice getDice() {
+        return dice;
+    }
+
+    public Integer getCurrentPlayer() {
+        return currentPlayer;
+    }
+
+    public Integer[][] getPlayerBeetles() {
+        return playerBeetles;
+    }
+
+    public Integer getNumPlayers() {
+        return numPlayers;
+    }
+
+    public Integer[] getPlayerCard(Integer playerNumber){
+        return this.getPlayerBeetles()[playerNumber];
+    }
+
+    public void setCurrentPlayer(Integer currentPlayer) {
+        this.currentPlayer = currentPlayer;
+    }
+
+    public void setPlayerBeetles(Integer player, Integer diceRoll) {
+        this.playerBeetles[player][diceRoll]++;
+        //return this.checkWinner(player);
+    }
+
+    public void nextPlayer(){
+        this.currentPlayer = (this.currentPlayer + 1) % this.numPlayers;
+    }
+
+    public void refreshBeetle(Integer player){
+        this.playerBeetles[player] = new Integer[] {0, 0, 0, 0, 0, 0};
+    }
+
+
+    public Boolean checkWinner(Integer player){
+        if(this.beetleIsComplete(player)){
+            this.scoreboard[player] += 6;
+            if(this.getScore(player) == 30){
+                return true;
+            } else {
+                this.refreshBeetle(player);
+            }
+        }
+        return false;
+    }
+
+    public Boolean beetleIsComplete(Integer player){
+        Integer[] playerBeetle = getPlayerCard(player);
+        for(int i = 0; i < 6; i++){
+            if(playerBeetle[i] == 0)
+                return false;
+        }
+        return true;
+    }
+
+    public Integer getScore(Integer player){
+        return this.scoreboard[player];
+    }
+}

src/main/java/com/github/zipcodewilmington/casino/games/Beetle/BeetleGame.java

@@ -0,0 +1,86 @@
+package com.github.zipcodewilmington.casino.games.Beetle;
+
+import com.github.zipcodewilmington.casino.GameInterface;
+import com.github.zipcodewilmington.casino.PlayerInterface;
+
+import java.util.ArrayList;
+
+public class BeetleGame implements GameInterface {
+    private ArrayList<PlayerInterface> players = new ArrayList<PlayerInterface>();
+    private Beetle game;
+    private Boolean isRunning = false;
+    private PlayerInterface player;
+    public void add(PlayerInterface player){
+        players.add(player);
+    }
+
+    /**
+     * removes a player from the game
+     * @param player the player to be removed from the game
+     */
+    public void remove(PlayerInterface player){
+        players.remove(player);
+    }
+
+    /**
+     * specifies how the game will run
+     */
+    public void run(){
+        Integer turnCount = 0;
+        if(isRunning){
+            turnCount++;
+            this.nextPlayer();
+            game.getDice().tossAndSum();
+            executeTurn();
+             isGameOver(game.checkWinner(game.getCurrentPlayer()));
+        }
+        System.out.println("game over after " + turnCount);
+    }
+
+    public void isGameOver(boolean playerWon){
+        if(playerWon){
+            isRunning = false;
+        }
+    }
+    public void nextPlayer(){
+        game.setCurrentPlayer(-1);
+        game.nextPlayer();
+    }
+
+    public void executeTurn(){
+        Integer currentPlayer = game.getCurrentPlayer();
+        game.setPlayerBeetles(currentPlayer, game.getDice().tossAndSum());
+    }
+
+    /**
+     * Calculate player's winning payout amount of bet x multiplier
+     * @return (double) amount of money winnings
+     */
+    public Integer calculateWinnings(Integer multiplier, Integer betAmount){
+        return 0;
+    }
+
+    /**
+     * Subtract the bet amount from player's balance
+     */
+    public void subtractBetFromBalance(Integer betAmount){
+
+    }
+
+
+    /**
+     * Add winnings amount to player's balance
+     */
+    public void addMoneyToBalance(PlayerInterface Player, Integer winnings){
+
+    }
+
+    public void initGame(Integer players){
+        this.game = new Beetle(this.players.size());
+        this.isRunning = true;
+        this.run();
+    }
+
+
+
+}

src/main/java/com/github/zipcodewilmington/casino/games/Beetle/BeetlePlayer.java

@@ -0,0 +1,9 @@
+package com.github.zipcodewilmington.casino.games.Beetle;
+
+public class BeetlePlayer {
+    private Integer bet;
+
+    public BeetlePlayer(){
+
+    }
+}