State transition changes

Assignments/Assignment-2/test

@@ -0,0 +1 @@
+

Assignments/Assignment-3/Assignment_3_BenchMark_Insertion_Sort.csv

@@ -0,0 +1,10 @@
+Number of Reps,N,Random,Ordered,Reverse Ordered,Partially Ordered
+100,500,0.796886,0.411288,0.771079,0.351973,
+100,1000,1.26744,0.211929,2.1041220000000003,0.38415900000000003,
+100,2000,3.577124,0.196373,7.024915999999999,1.020151,
+100,4000,13.394235000000002,0.164645,27.528134,3.6681,
+100,8000,54.963801999999994,0.185653,109.694725,13.631863000000001,
+100,16000,228.87135600000002,0.214038,439.061367,53.774669,
+100,32000,1022.6707670000001,0.281978,1785.9298680000002,229.829533,
+100,64000,5109.660646,0.48274700000000004,7166.697730000001,1041.272522,
+100,128000,21258.790033999998,0.6721550000000001,30241.3736449,5653.250621,

src/main/java/edu/neu/coe/info6205/game/Game.java

@@ -0,0 +1,19 @@
+package edu.neu.coe.info6205.game;
+
+public interface Game<T, G> {
+    /**
+     * to make the next move
+     * <p>
+     * TODO this always returns null.
+     */
+    Move<T> move();
+
+    void display();
+
+    boolean isGameOver();
+
+    Player<T, G> getWinner();
+
+    Player<T, G> checkWinner();
+
+}

src/main/java/edu/neu/coe/info6205/game/GameException.java

@@ -0,0 +1,7 @@
+package edu.neu.coe.info6205.game;
+
+public class GameException extends RuntimeException {
+    public GameException(String message) {
+        super(message);
+    }
+}

src/main/java/edu/neu/coe/info6205/game/Move.java

@@ -0,0 +1,30 @@
+package edu.neu.coe.info6205.game;
+
+public class  Move<T> {
+    final Integer row;
+    final Integer column;
+    T val;
+
+    public Move(int row, int column) {
+        this.row = row;
+        this.column = column;
+    }
+
+    public Move(int row, int column, T val) {
+        this.row = row;
+        this.column = column;
+        this.val = val;
+    }
+
+    public Integer getRow() {
+        return row;
+    }
+
+    public Integer getColumn() {
+        return column;
+    }
+
+    public T getVal() {
+        return val;
+    }
+}

src/main/java/edu/neu/coe/info6205/game/MoveStats.java

@@ -0,0 +1,15 @@
+package edu.neu.coe.info6205.game;
+
+public class MoveStats<T> {
+
+    final Move<T> move;
+    final Long timeInMillis;
+
+    final Boolean validMove;
+
+    MoveStats(Move<T> move, long timeInMillis, boolean validMove) {
+        this.move = move;
+        this.timeInMillis = timeInMillis;
+        this.validMove = validMove;
+    }
+}

src/main/java/edu/neu/coe/info6205/game/MultiPlayerGame.java

@@ -0,0 +1,6 @@
+package edu.neu.coe.info6205.game;
+
+
+public abstract class MultiPlayerGame<T> implements Game<T, Object> {
+
+}

src/main/java/edu/neu/coe/info6205/game/Player.java

@@ -0,0 +1,55 @@
+package edu.neu.coe.info6205.game;
+
+public class Player<T, G> {
+    private final int playerId;
+    private final boolean isBot;
+
+    private final PlayerStats<T> playerStats;
+    private Solver<T, G> moveGenerator;
+
+    public Player(int playerId, boolean isBot) {
+        this.playerId = playerId;
+        this.isBot = isBot;
+        playerStats = new PlayerStats<>();
+    }
+
+    public Player(int playerId, boolean isBot, Solver<T, G> moveGenerator) {
+        this.playerId = playerId;
+        this.isBot = isBot;
+        this.moveGenerator = moveGenerator;
+        playerStats = new PlayerStats<>();
+    }
+
+    public void addMove(Move<T> move, long timeInMilli, boolean validMove) {
+        this.playerStats.add(new MoveStats<>(move, timeInMilli, validMove));
+    }
+
+    public int getPlayerId() {
+        return playerId;
+    }
+
+    public boolean isBot() {
+        return isBot;
+    }
+
+    public int getNumberOfMoves() {
+        return playerStats.getNumberOfMoves();
+    }
+
+    public int getValidNumberOfMoves() {
+        return playerStats.getNumberOfValidMoves();
+    }
+
+    public Solver<T, G> getMoveGenerator() {
+        return moveGenerator;
+    }
+
+    public long getTotalTime() {
+        return playerStats.getTotalTime();
+    }
+
+    public double getAverageTimePerMove() {
+        return playerStats.getAverageTimePerMove();
+    }
+
+}

src/main/java/edu/neu/coe/info6205/game/PlayerStats.java

@@ -0,0 +1,39 @@
+package edu.neu.coe.info6205.game;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PlayerStats<T> {
+
+    private int numberOfMoves = 0;
+    private int numberOfValidMoves = 0;
+    private final List<MoveStats<T>> moveStatsList;
+
+    PlayerStats() {
+        moveStatsList = new ArrayList<>();
+    }
+
+    public void add(MoveStats<T> move) {
+        moveStatsList.add(move);
+        numberOfMoves++;
+        if (move.validMove) numberOfValidMoves++;
+    }
+
+    public int getNumberOfMoves() {
+        return numberOfMoves;
+    }
+
+    public int getNumberOfValidMoves() { return numberOfValidMoves; }
+
+    public List<MoveStats<T>> getMoveStatsList() {
+        return moveStatsList;
+    }
+
+    public long getTotalTime() {
+        return moveStatsList.stream().map(p -> p.timeInMillis).reduce(0L, Long::sum);
+    }
+
+    public double getAverageTimePerMove() {
+        return (double) getTotalTime()/moveStatsList.size();
+    }
+}

src/main/java/edu/neu/coe/info6205/game/Runner.java

@@ -0,0 +1,48 @@
+package edu.neu.coe.info6205.game;
+
+import edu.neu.coe.info6205.game.generics.Board;
+import edu.neu.coe.info6205.game.generics.GridPosition;
+import edu.neu.coe.info6205.game.generics.StateTransition;
+import edu.neu.coe.info6205.game.singlePlayerGame.Games.Sudoku.Sudoku;
+import edu.neu.coe.info6205.game.singlePlayerGame.Games.Sudoku.SudokuCreator;
+import edu.neu.coe.info6205.game.singlePlayerGame.Games.Sudoku.SudokuSolver;
+import edu.neu.coe.info6205.game.singlePlayerGame.UserGame;
+
+public class Runner {
+
+    public static void main(String[] args) {
+
+
+        Sudoku game = new Sudoku(
+                new SudokuCreator(), true, new SudokuSolver(3), 3);
+        game.display();
+        /*System.out.println(game.getGrid().hashCode());
+        game.fillWrapper(new StateTransition<>(0, 0, 3));
+        System.out.println("after adding 3 - " + getHash(game.getGrid()));
+        game.fillWrapper(new StateTransition<>(0, 0, 4));
+        System.out.println("after adding 4 - " + getHash(game.getGrid()));
+        game.fillWrapper(new StateTransition<>(0, 0, 3));
+        System.out.println("after adding 3 - " + getHash(game.getGrid()));
+
+         */
+        game.run();
+        game.checkWinner();
+        game.display();
+        // TODO check this assignment
+        Player<Integer, UserGame<Board<Integer, GridPosition, StateTransition<Integer, GridPosition>>, Integer>> winner = game.getWinner();
+        System.out.println(winner.getTotalTime());
+        System.out.println(winner.getAverageTimePerMove());
+
+    }
+
+    private static int getHash(Integer[][] grid) {
+        StringBuilder sb = new StringBuilder();
+
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 9; j++) {
+                sb.append(grid[i][j] != null ? grid[i][j] : "_");
+            }
+        }
+        return sb.toString().hashCode();
+    }
+}

src/main/java/edu/neu/coe/info6205/game/Solver.java

@@ -0,0 +1,18 @@
+package edu.neu.coe.info6205.game;
+
+
+public interface Solver<T, G> {
+
+    void solve(G game);
+
+    /**
+     * TODO this always returns null.
+     *
+     * @param grid the grid.
+     * @return a StateTransition.
+     */
+    Move<T> getMove(T[][] grid);
+
+    SolverType getType();
+
+}

src/main/java/edu/neu/coe/info6205/game/SolverType.java

@@ -0,0 +1,7 @@
+package edu.neu.coe.info6205.game;
+
+public enum SolverType {
+
+    SingleTurnSolver,
+    MultiTurnSolver
+}

src/main/java/edu/neu/coe/info6205/game/generics/Board.java

@@ -0,0 +1,9 @@
+package edu.neu.coe.info6205.game.generics;
+
+public interface Board<StateType, Position, BoardMove> {
+
+    StateType getState(Position position);
+
+    Board<StateType, Position, BoardMove> move(BoardMove move);
+
+}

src/main/java/edu/neu/coe/info6205/game/generics/Board_Grid.java

@@ -0,0 +1,67 @@
+package edu.neu.coe.info6205.game.generics;
+
+import java.util.Arrays;
+
+public class Board_Grid<StateType> implements Board<StateType, GridPosition, StateTransition<StateType, GridPosition>> {
+    public Board_Grid(Object[][] grid) {
+        this.grid = grid;
+    }
+
+    public Board_Grid(int rows, int columns) {
+        this.grid = new Object[rows][columns];
+    }
+
+    @Override
+    public StateType getState(GridPosition gridPosition) {
+        if (gridPosition != null)
+            // TODO this cast is OK -- it's because we have to store the grid as an array of Object
+            //noinspection unchecked
+            return (StateType) grid[gridPosition.x][gridPosition.y];
+        else return null;
+    }
+
+    /**
+     * Method to generate a new Board from <code>this</code>> Board, by applying the transitions defined by the given <code>move</code>>.
+     *
+     * @param move a move in the current game.
+     * @return a new Board based on <code>this</code> board and the effects of <code>move</code>.
+     */
+    @Override
+    public Board<StateType, GridPosition, StateTransition<StateType, GridPosition>> move(StateTransition<StateType, GridPosition> move) {
+        Object[][] newGrid = Arrays.copyOf(grid, grid.length); // TODO check this
+        Board_Grid<StateType> newBoard = new Board_Grid<>(newGrid);
+        StateTransition<StateType, GridPosition> current = move;
+        while (current != null) {
+            // NOTE: the endPosition is not necessarily different from the startPosition.
+            // If the two positions are the same, then the state must be different.
+            GridPosition endPosition = current.endPosition();
+            // TODO create a method to update the state of the board at some position.
+            newBoard.grid[endPosition.x][endPosition.y] = current.transitionFunction().apply(getState(current.startPosition()));
+            current = current.next();
+        }
+        return newBoard;
+    }
+
+//    @Override
+//    public Board<StateType, GridPosition, StateTransition> move(StateTransition move) {
+//        Object[][] newGrid = Arrays.copyOf(grid,grid.length); // TODO check this
+//        Board_Grid<StateType, StateTransition> newBoard = new Board_Grid<>(newGrid);
+//        StateTransition current = move;
+//        while (current != null) {
+//
+//        }
+//        return null;
+//    }
+
+    //
+//    @Override
+//    public Board<T, GridPosition, StateTransition<T>> move(StateTransition<T> move) {
+//        Object[][] newGrid = Arrays.copyOf(grid,grid.length); // TODO check this
+//        Board_Grid<T> newBoard = new Board_Grid<>(newGrid);
+//        newBoard.move(move);
+//        return newBoard;
+//    }
+
+    // This is essentially a StateType[][]. It's just that Java doesn't really support that concept.
+    protected final Object[][] grid;
+}