add basic core structure and first parts of antGame implementation

.idea/compiler.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <annotationProcessing>
+      <profile default="true" name="Default" enabled="true" />
+    </annotationProcessing>
+  </component>
+</project>

build.gradle

@@ -13,4 +13,6 @@ repositories {
 
 dependencies {
     testCompile group: 'junit', name: 'junit', version: '4.12'
+    compileOnly 'org.projectlombok:lombok:1.18.10'
+    annotationProcessor 'org.projectlombok:lombok:1.18.10'
 }

src/main/java/core/Action.java

@@ -0,0 +1,8 @@
+package core;
+
+public interface Action {
+    int getIndex();
+    String toString();
+    int hashCode();
+    boolean equals(Object obj);
+}

src/main/java/core/ActionSpace.java

@@ -0,0 +1,9 @@
+package core;
+
+import java.util.Set;
+
+public interface ActionSpace<A extends Enum> {
+    Set<Action> getAllActions();
+    int getNumberOfAction();
+    void addAction(DiscreteAction<A> a);
+}

src/main/java/core/DiscreteAction.java

@@ -0,0 +1,36 @@
+package core;
+
+public class DiscreteAction<A extends Enum> implements Action{
+    private A action;
+
+    public DiscreteAction(A action){
+        this.action = action;
+    }
+
+    @Override
+    public int getIndex(){
+       return action.ordinal();
+    }
+
+   @Override
+    public String toString(){
+        return action.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        return getIndex();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+
+        return getIndex() == ((DiscreteAction) obj).getIndex();
+    }
+}

src/main/java/core/DiscreteActionSpace.java

@@ -0,0 +1,28 @@
+package core;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class DiscreteActionSpace<A extends Enum> implements ActionSpace<A>{
+    private Set<Action> actions;
+
+    public DiscreteActionSpace(){
+        actions = new HashSet<>();
+    }
+
+    @Override
+    public void addAction(DiscreteAction<A> action){
+        actions.add(action);
+    }
+
+    @Override
+    public int getNumberOfAction(){
+        return actions.size();
+    }
+
+
+    @Override
+    public Set<Action> getAllActions(){
+        return actions;
+    }
+}

src/main/java/core/Observation.java

@@ -0,0 +1,4 @@
+package core;
+
+public interface Observation {
+}

src/main/java/core/RNG.java

@@ -0,0 +1,19 @@
+package core;
+
+import java.util.Random;
+
+public class RNG {
+    private static final Random rng;
+    private static final int SEED = 123;
+    static {
+        rng = new Random(SEED);
+    }
+
+    public static Random getRandom() {
+        return rng;
+    }
+
+    public static void reseed(){
+        rng.setSeed(SEED);
+    }
+}

src/main/java/core/State.java

@@ -0,0 +1,7 @@
+package core;
+
+public interface State {
+    String toString();
+    int hashCode();
+    boolean equals(Object obj);
+}

src/main/java/core/StateActionHashTable.java

@@ -0,0 +1,66 @@
+package core;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Premise: All states have the complete action space
+ */
+public class StateActionHashTable<A extends Enum> implements StateActionTable {
+
+    private final Map<State, Map<Action, Double>> table;
+    private ActionSpace<A> actionSpace;
+
+    public StateActionHashTable(ActionSpace<A> actionSpace){
+        table =  new HashMap<>();
+        this.actionSpace = actionSpace;
+    }
+
+    /*
+       If the state is not present in the table at the time of
+       calling this method the DEFAULT_VALUE gets returned BUT
+       no the missing state is not inserted into the table!
+
+       Inserting of missing states is ONLY done in "setValue()"
+       method.
+     */
+    @Override
+    public double getValue(State state, Action action) {
+        final Map<Action, Double> actionValues = table.get(state);
+        if (actionValues != null) {
+            return actionValues.get(action);
+        }
+        return DEFAULT_VALUE;
+    }
+
+    /*
+       Update the value of an action for a specific state.
+       If the state is not present in the table yet,
+       it will get stored in combination with every action
+       from the action space initialized with the default value.
+     */
+    @Override
+    public void setValue(State state, Action action, double value) {
+        final Map<Action, Double> actionValues;
+        if (table.containsKey(state)) {
+            actionValues = table.get(state);
+        } else {
+            actionValues = createDefaultActionValues();
+            table.put(state, actionValues);
+        }
+        actionValues.put(action, value);
+    }
+
+    @Override
+    public Map<Action, Double> getActionValues(State state) {
+        return null;
+    }
+
+    private Map<Action, Double> createDefaultActionValues(){
+        final Map<Action, Double> defaultActionValues = new HashMap<>();
+        for(Action action: actionSpace.getAllActions()){
+            defaultActionValues.put(action, DEFAULT_VALUE);
+        }
+        return defaultActionValues;
+    }
+}

src/main/java/core/StateActionTable.java

@@ -0,0 +1,12 @@
+package core;
+
+import java.util.Map;
+
+public interface StateActionTable {
+    double DEFAULT_VALUE = 0.0;
+
+    double getValue(State state, Action action);
+    void setValue(State state, Action action, double value);
+
+    Map<Action, Double> getActionValues(State state);
+}

src/main/java/core/StepResult.java

@@ -0,0 +1,15 @@
+package core;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class StepResult {
+    private Observation observation;
+    private double reward;
+    private boolean done;
+    private String info;
+}

src/main/java/evironment/antGame/AntAction.java

@@ -0,0 +1,10 @@
+package evironment.antGame;
+
+public enum AntAction {
+    MOVE_UP,
+    MOVE_RIGHT,
+    MOVE_DOWN,
+    MOVE_LEFT,
+    PICK_UP,
+    DROP_DOWN,
+}

src/main/java/evironment/antGame/AntObservation.java

@@ -0,0 +1,6 @@
+package evironment.antGame;
+
+import core.Observation;
+
+public class AntObservation implements Observation {
+}

src/main/java/evironment/antGame/AntState.java

@@ -0,0 +1,7 @@
+package evironment.antGame;
+
+import core.State;
+
+// somewhat the "brain" of the agent, current known setting of the environment
+public class AntState implements State {
+}

src/main/java/evironment/antGame/AntWorld.java

@@ -0,0 +1,28 @@
+package evironment.antGame;
+
+import core.DiscreteAction;
+import core.Observation;
+import core.RNG;
+import core.StepResult;
+
+public class AntWorld {
+    private Grid grid;
+
+    public AntWorld(int width, int height, double foodDensity){
+        grid = new Grid(width, height, foodDensity);
+    }
+
+    public AntWorld(){
+        this(30, 30, 0.1);
+    }
+
+    public StepResult step(DiscreteAction<AntAction> action){
+        Observation observation = new AntObservation();
+        return new StepResult(observation, 0.0, false, "");
+    }
+
+    public void reset(){
+        RNG.reseed();
+        grid.initCells();
+    }
+}

src/main/java/evironment/antGame/Cell.java

@@ -0,0 +1,23 @@
+package evironment.antGame;
+
+public class Cell {
+    private CellType type;
+    private int food;
+
+    public Cell(CellType cellType, int foodAmount){
+        type = cellType;
+        food = foodAmount;
+    }
+
+    public Cell(CellType cellType){
+       this(cellType, 0);
+    }
+
+    public void setFoodCount(int amount){
+        food = amount;
+    }
+
+    public int getFoodCount(){
+        return food;
+    }
+}

src/main/java/evironment/antGame/CellType.java

@@ -0,0 +1,8 @@
+package evironment.antGame;
+
+public enum CellType {
+    START,
+    FREE,
+    OBSTACLE,
+    FOOD,
+}

src/main/java/evironment/antGame/Grid.java

@@ -0,0 +1,51 @@
+package evironment.antGame;
+
+import core.RNG;
+
+import java.awt.*;
+
+public class Grid {
+    private int width;
+    private int height;
+    private double foodDensity;
+    private Point start;
+    private Cell[][] grid;
+
+    public Grid(int width, int height, double foodDensity){
+        this.width = width;
+        this.height = height;
+        this.foodDensity = foodDensity;
+
+        grid = new Cell[width][height];
+    }
+
+    public void initCells(){
+        for(int x = 0; x < width; ++x){
+            for(int y = 0; y < height; ++y){
+                if( RNG.getRandom().nextDouble() < foodDensity){
+                    grid[x][y] = new Cell(CellType.FOOD, 1);
+                }else{
+                    grid[x][y] = new Cell(CellType.FREE);
+                }
+            }
+        }
+        start = new Point(RNG.getRandom().nextInt(width), RNG.getRandom().nextInt(height));
+        grid[start.x][start.y] = new Cell(CellType.START);
+    }
+
+    public Point getStartPoint(){
+        return start;
+    }
+
+    public Cell[][] getGrid(){
+        return grid;
+    }
+
+    public int getWidth(){
+        return width;
+    }
+    public int getHeight(){
+        return height;
+    }
+
+}