Solved the Problem

SnakeAndLadder/pom.xml

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.main</groupId>
+    <artifactId>SnakeAndLadder</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>5.12.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.32</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- Additional JUnit dependencies -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.8.1</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>

SnakeAndLadder/src/main/java/org/main/Dice.java

@@ -0,0 +1,39 @@
+package org.main;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.Random;
+
+/**
+ *
+ */
+@Getter
+@Setter
+public class Dice {
+    private Integer numOfDices;
+    private Integer minDiceRollValue;
+    private Integer maxDiceRollValue;
+
+    public Dice(Integer numOfDices) {
+        this.numOfDices = numOfDices;
+        updateMinAndMaxDiceRollValues(numOfDices);
+    }
+
+    public void updateMinAndMaxDiceRollValues(Integer numOfDices) {
+        minDiceRollValue = numOfDices;
+        maxDiceRollValue = 6*numOfDices;
+    }
+
+    public int rollDice() {
+        return getRandomNumberBetween(minDiceRollValue, maxDiceRollValue);
+    }
+
+    private int getRandomNumberBetween(int min, int max) throws IllegalArgumentException {
+        if (max < min) {
+            throw new IllegalArgumentException("Max value "+max+" should be less than min "+min);
+        }
+        Random r = new Random();
+        return r.nextInt((max-min)+1)+min;
+    }
+}

SnakeAndLadder/src/main/java/org/main/GameBoard.java

@@ -0,0 +1,5 @@
+package org.main;
+
+public interface GameBoard {
+
+}

SnakeAndLadder/src/main/java/org/main/GameFilePathManager.java

@@ -0,0 +1,40 @@
+package org.main;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+@Getter
+@Setter(AccessLevel.PRIVATE)
+public class GameFilePathManager {
+    private Path filePath;
+
+    public GameFilePathManager() {
+        filePath = null;
+    }
+
+    public Boolean fileExists(Path path) {
+        if (Files.exists(path)) {
+            return true;
+        }
+        return false;
+    }
+
+    public Boolean validateAndSetFilePath(String path) {
+        if (path == null || path.isEmpty()) {
+            System.out.println("The File path provided for the game " +path+ " is not valid");
+        } else {
+            Path tempFilePath = Paths.get(path);
+            if (fileExists(tempFilePath)) {
+                filePath = tempFilePath;
+                return true;
+            }
+        }
+        return false;
+    }
+
+}

SnakeAndLadder/src/main/java/org/main/GamePlay.java

@@ -0,0 +1,4 @@
+package org.main;
+
+public interface GamePlay {
+}

SnakeAndLadder/src/main/java/org/main/GamePlayers.java

@@ -0,0 +1,4 @@
+package org.main;
+
+public interface GamePlayers {
+}

SnakeAndLadder/src/main/java/org/main/LoadGameBoard.java

@@ -0,0 +1,8 @@
+package org.main;
+
+import java.io.FileNotFoundException;
+
+public interface LoadGameBoard {
+    public void LoadGameboard() throws FileNotFoundException;
+}
+

SnakeAndLadder/src/main/java/org/main/Main.java

@@ -0,0 +1,30 @@
+package org.main;
+
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) throws FileNotFoundException, InterruptedException {
+
+        System.out.println("Hello and welcome to the Snake and Ladder!");
+        Scanner scanner = new Scanner(System.in);
+        String filepath="";
+
+        GameFilePathManager gameFilePathManager = new GameFilePathManager();
+        while (!(gameFilePathManager.validateAndSetFilePath(filepath))) {
+            System.out.println("Please give the valid game Loader file path");
+            filepath = scanner.nextLine();
+        }
+        GameBoard gameBoard = new SnakeAndLadderGameBoard(gameFilePathManager, new Dice(2), 120);
+        SnakeAndLadderGameBoardLoader snakeAndLadderGameBoardLoader = new SnakeAndLadderGameBoardLoader(gameBoard);
+        snakeAndLadderGameBoardLoader.LoadGameboard();
+
+        for(int i =0; i<1; i++) {
+            SnakeAndLadderGamePlayers snakeAndLadderGamePlayers = new SnakeAndLadderGamePlayers();
+            snakeAndLadderGamePlayers.LoadPlayers(snakeAndLadderGameBoardLoader.getSnakeAndLadderGamePlayersNames());
+            SnakeAndLadderGameBoardPlay snakeAndLadderGameBoardPlay = new SnakeAndLadderGameBoardPlay((SnakeAndLadderGameBoard)gameBoard, snakeAndLadderGamePlayers);
+            snakeAndLadderGameBoardPlay.StartGame();
+            System.out.println("Thanks for playing the snake and ladder Game!!!!");
+        }
+    }
+}

SnakeAndLadder/src/main/java/org/main/MovementCause.java

@@ -0,0 +1,16 @@
+package org.main;
+
+import lombok.Getter;
+
+@Getter
+public enum MovementCause {
+    SNAKE_BITE("Snake bite"),
+    GOT_LADDER("Got Ladder"),
+    DICE("Dice");
+
+    MovementCause(String description) {
+        this.description = description;
+    }
+
+    private String description;
+}

SnakeAndLadder/src/main/java/org/main/Player.java

@@ -0,0 +1,45 @@
+package org.main;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.util.ArrayList;
+
+@Getter
+@Setter
+class PlayerMove {
+    private Integer initialPosition;
+    private Integer finalPosition;
+    private MovementCause cause;
+
+    public PlayerMove(Integer initialPosition, Integer finalPosition, MovementCause cause) {
+        this.initialPosition = initialPosition;
+        this.finalPosition = finalPosition;
+        this.cause = cause;
+    }
+}
+
+@Getter
+@Setter
+@ToString
+public class Player {
+    private String name;
+    private Integer curPosition;
+    private PlayerStatus playerStatus;
+    private ArrayList<PlayerMove> moves;
+
+    public Player(String name) {
+        this.name = name;
+        this.curPosition = 0;
+        this.playerStatus = PlayerStatus.IDLE;
+        this.moves = new ArrayList<>();
+    }
+
+    public boolean won() {
+        if (this.playerStatus == PlayerStatus.WON) {
+            return true;
+        }
+        return false;
+    }
+}

SnakeAndLadder/src/main/java/org/main/PlayerStatus.java

@@ -0,0 +1,7 @@
+package org.main;
+
+public enum PlayerStatus {
+    PLAYING,
+    WON,
+    IDLE;
+}

SnakeAndLadder/src/main/java/org/main/SnakeAndLadderGameBoard.java

@@ -0,0 +1,35 @@
+package org.main;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.util.HashMap;
+
+@Setter
+@Getter
+@ToString
+public class SnakeAndLadderGameBoard implements GameBoard {
+    private GameFilePathManager gameFilePathManager;
+    private HashMap<Integer, Integer> SnakesMap;
+    private HashMap<Integer, Integer> LadderMap;
+    private Integer boardSize;
+    private Dice dice;
+
+    public SnakeAndLadderGameBoard(GameFilePathManager gameFilePathManager, Dice dice, Integer size) {
+        this.gameFilePathManager = gameFilePathManager;
+        SnakesMap = new HashMap<>();
+        LadderMap = new HashMap<>();
+        this.dice = dice;
+        this.boardSize = size;
+    }
+
+    public Integer caughtBySnake(Integer curPosition) {
+        return SnakesMap.getOrDefault(curPosition, -1);
+    }
+
+    public Integer gotLadder(Integer curPosition) {
+        return LadderMap.getOrDefault(curPosition, -1);
+    }
+
+}

SnakeAndLadder/src/main/java/org/main/SnakeAndLadderGameBoardLoader.java

@@ -0,0 +1,91 @@
+package org.main;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+@Getter
+@Setter
+public class SnakeAndLadderGameBoardLoader implements LoadGameBoard{
+    private GameBoard gameBoard;
+    private Scanner gameBoardFileScanner;
+    private ArrayList<String> snakeAndLadderGamePlayersNames;
+    private SnakeAndLadderGameBoard snakeAndLadderGameBoard;
+
+    public SnakeAndLadderGameBoardLoader(GameBoard gameBoard) {
+        this.gameBoard = gameBoard;
+        this.snakeAndLadderGamePlayersNames = new ArrayList<>();
+    }
+
+    private void readGameBoardFile() throws FileNotFoundException {
+        snakeAndLadderGameBoard = (SnakeAndLadderGameBoard)(gameBoard);
+        Path path = snakeAndLadderGameBoard.getGameFilePathManager().getFilePath();
+        File file = new File(String.valueOf(path));
+        gameBoardFileScanner = new Scanner(file);
+    }
+
+    private boolean checkIfGameBoardIsOfSnakeAndLadder() {
+        return (gameBoard instanceof SnakeAndLadderGameBoard);
+    }
+
+    private void LoadSnakes(int numOfSnakes) {
+        while (numOfSnakes > 0) {
+            Integer snakeHead = gameBoardFileScanner.nextInt();
+            Integer snakeTail = gameBoardFileScanner.nextInt();
+            //System.out.println("Adding the snake with snakeHead "+snakeHead+" and snakeTail "+snakeTail);
+            snakeAndLadderGameBoard.getSnakesMap().put(snakeHead, snakeTail);
+            numOfSnakes--;
+        }
+    }
+
+    private void LoadLadders(int numOfLadders) {
+        while (numOfLadders > 0) {
+            Integer ladderHead = gameBoardFileScanner.nextInt();
+            Integer ladderTail = gameBoardFileScanner.nextInt();
+            //System.out.println("Adding the snake with ladderHead "+ladderHead+" and ladderTail "+ladderTail);
+            snakeAndLadderGameBoard.getLadderMap().put(ladderHead, ladderTail);
+            numOfLadders--;
+        }
+    }
+
+    private void LoadUsers(int numOfUsers) {
+        gameBoardFileScanner.nextLine();
+        while (numOfUsers > 0) {
+            String name = gameBoardFileScanner.nextLine();
+            //System.out.println("Adding a user with name "+name);
+            snakeAndLadderGamePlayersNames.add(name);
+            numOfUsers--;
+        }
+    }
+
+    @Override
+    public void LoadGameboard() throws FileNotFoundException {
+        if (checkIfGameBoardIsOfSnakeAndLadder()) {
+            readGameBoardFile();
+            //Load snakes
+            int numOfSnakes = gameBoardFileScanner.nextInt();
+            //System.out.println("Number of Snakes for the game is  = "+ numOfSnakes);
+            LoadSnakes(numOfSnakes);
+
+            //Load Ladders
+            int numOfLadders = gameBoardFileScanner.nextInt();
+            //System.out.println("Number of Ladders for the game is  = "+ numOfLadders);
+            LoadLadders(numOfLadders);
+
+            //Load Users
+            int numOfUsers = gameBoardFileScanner.nextInt();
+            //System.out.println("Number of Users for the game is  = "+ numOfUsers);
+            LoadUsers(numOfUsers);
+
+            gameBoardFileScanner.close();
+        } else {
+            System.out.println("The Object Provided for the class"+ SnakeAndLadderGameBoardLoader.class +" is not of type "+ SnakeAndLadderGameBoard.class);
+            System.exit(0);
+        }
+    }
+}