kaggle-environments 0.2.1__py3-none-any.whl → 1.20.1__py3-none-any.whl

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Direction.java

@@ -0,0 +1,166 @@
+package kore;
+
+
+public class Direction extends Point {
+
+    public static final Direction NORTH = new Direction(0, 1);
+    public static final Direction EAST = new Direction(1, 0);
+    public static final Direction SOUTH = new Direction(0, -1);
+    public static final Direction WEST = new Direction(-1, 0);
+    
+    private Direction(int x, int y) {
+        super(x, y);
+    }
+
+    public boolean equals(Direction other) {
+        return this.x == other.x && this.y == other.y;
+    }
+
+    public Direction rotateLeft() {
+        if (this.equals(Direction.NORTH)) {
+            return Direction.WEST;
+        }
+        if (this.equals(Direction.WEST)) {
+            return Direction.SOUTH;
+        }
+        if (this.equals(Direction.SOUTH)) {
+            return Direction.EAST;
+        }
+        if (this.equals(Direction.EAST)) {
+            return Direction.NORTH;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public Direction rotateRight() {
+        if (this.equals(Direction.NORTH)) {
+            return Direction.EAST;
+        }
+        if (this.equals(Direction.EAST)) {
+            return Direction.SOUTH;
+        }
+        if (this.equals(Direction.SOUTH)) {
+            return Direction.WEST;
+        }
+        if (this.equals(Direction.WEST)) {
+            return Direction.NORTH;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public Direction opposite() {
+        if (this.equals(Direction.NORTH)) {
+            return Direction.SOUTH;
+        }
+        if (this.equals(Direction.EAST)) {
+            return Direction.WEST;
+        }
+        if (this.equals(Direction.SOUTH)) {
+            return Direction.NORTH;
+        }
+        if (this.equals(Direction.WEST)) {
+            return Direction.EAST;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public String toChar() {
+        if (this.equals(Direction.NORTH)) {
+            return "N";
+        }
+        if (this.equals(Direction.EAST)) {
+            return "E";
+        }
+        if (this.equals(Direction.SOUTH)) {
+            return "S";
+        }
+        if (this.equals(Direction.WEST)) {
+            return "W";
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public String toString() {
+        if (this.equals(Direction.NORTH)) {
+            return "NORTH";
+        }
+        if (this.equals(Direction.EAST)) {
+            return "EAST";
+        }
+        if (this.equals(Direction.SOUTH)) {
+            return "SOUTH";
+        }
+        if (this.equals(Direction.WEST)) {
+            return "WEST";
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public int toIndex() {
+        if (this.equals(Direction.NORTH)) {
+            return 0;
+        }
+        if (this.equals(Direction.EAST)) {
+            return 1;
+        }
+        if (this.equals(Direction.SOUTH)) {
+            return 2;
+        }
+        if (this.equals(Direction.WEST)) {
+            return 3;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public static Direction fromString(String dirStr) {
+        switch(dirStr) {
+            case "NORTH":
+                return Direction.NORTH;
+            case "EAST":
+                return Direction.EAST;
+            case "SOUTH":
+                return Direction.SOUTH;
+            case "WEST":
+                return Direction.WEST;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public static Direction fromChar(char dirChar) {
+        switch(dirChar) {
+            case 'N':
+                return Direction.NORTH;
+            case 'E':
+                return Direction.EAST;
+            case 'S':
+                return Direction.SOUTH;
+            case 'W':
+                return Direction.WEST;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public static Direction fromIndex(int index) {
+        switch(index) {
+            case 0:
+                return Direction.NORTH;
+            case 1:
+                return Direction.EAST;
+            case 2:
+                return Direction.SOUTH;
+            case 3:
+                return Direction.WEST;
+        }
+        throw new IllegalStateException("invalid direction");
+    }
+
+    public static Direction[] listDirections() {
+        return new Direction[]{
+            Direction.NORTH,
+            Direction.EAST,
+            Direction.SOUTH,
+            Direction.WEST
+        };
+    }
+
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Fleet.java

@@ -0,0 +1,72 @@
+package kore;
+
+public class Fleet {
+
+    public final String id;
+    public int shipCount;
+    public Direction direction;
+    public Point position;
+    public String flightPlan;
+    public double kore;
+    public final int playerId;
+    public final Board board;
+    
+    public Fleet(String fleetId, int shipCount, Direction direction, Point position, double kore, String flightPlan, int playerId, Board board) {
+        this.id = fleetId;
+        this.shipCount = shipCount;
+        this.direction = direction;
+        this.position = position;
+        this.flightPlan = flightPlan;
+        this.kore = kore;
+        this.playerId = playerId;
+        this.board = board;
+    }
+
+    public Fleet cloneToBoard(Board board) {
+        return new Fleet(this.id, this.shipCount, this.direction, this.position, this.kore, this.flightPlan, this.playerId, board);
+    }
+
+    public Cell cell() {
+        return this.board.getCellAtPosition(this.position);
+    }
+
+    public Player player() {
+        return this.board.players[this.playerId];
+    }
+
+    public double collectionRate() {
+        return Math.min(Math.log(this.shipCount) / 10, .99);
+    }
+
+    /**
+     * Returns the length of the longest possible flight plan this fleet can be assigned
+     * @return
+     */
+    public static int maxFlightPlanLenForShipCount(int shipCount) {
+        return (int) (Math.floor(2 * Math.log(shipCount)) + 1);
+    }
+
+    /**
+     * Converts a fleet back to the normalized observation subset that constructed it.
+     */
+    public String[] observation() {
+        return new String[]{
+            String.valueOf(this.position.toIndex(this.board.configuration.size)), 
+            String.valueOf(this.kore), 
+            String.valueOf(this.shipCount), 
+            String.valueOf(this.direction.toIndex()), 
+            this.flightPlan
+        };
+    }
+
+    public boolean lessThanOtherAlliedFleet(Fleet other) {
+        if (this.shipCount != other.shipCount) {
+            return this.shipCount < other.shipCount;
+        }
+        if (this.kore != other.kore) {
+            return this.kore < other.kore;
+        }
+        return this.direction.toIndex() > other.direction.toIndex();
+}
+
+    }

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/KoreJson.java

@@ -0,0 +1,97 @@
+package kore;
+
+/**
+ * Don't want to import a full blown json library
+ * Our json is simple enough to use this
+ */
+public class KoreJson {
+
+    public static int getIntFromJson(String raw, String key) {
+        return (int)Integer.parseInt(getNumberPartFromJson(raw, key));
+    }
+
+    private static String getNumberPartFromJson(String raw, String key) {
+        int keyIdx = raw.indexOf(key);
+        if (keyIdx < 0) {
+            throw new IllegalStateException("couldn't find key in raw");
+        }
+        String rest = raw.substring(keyIdx + key.length() + 3);
+        int end = rest.indexOf(",") > 0 ? rest.indexOf(",") : rest.indexOf("}");
+        return rest.substring(0, end);
+    }
+
+    public static int getPlayerIdxFromJson(String raw) {
+        String key = "'player': ";
+        String key2 = "\"player\": ";
+        int keyIdx = Math.max(raw.indexOf(key), raw.indexOf(key2));
+        if (keyIdx < 0) {
+            throw new IllegalStateException("couldn't find key in raw");
+        }
+        String rest = raw.substring(keyIdx + key.length());
+        int end = rest.indexOf(",") > 0 ? rest.indexOf(",") : rest.indexOf("}");
+        return (int)Integer.parseInt(rest.substring(0, end));
+    }
+
+    public static String getStrFromJson(String raw, String key) {
+        int keyIdx = raw.indexOf(key);
+        if (keyIdx < 0) {
+            throw new IllegalStateException("couldn't find key in raw");
+        }
+        String rest = raw.substring(keyIdx + key.length() + 4);
+        int end = rest.indexOf(",") > 0 ? rest.indexOf(",") : rest.indexOf("}");
+        return rest.substring(0, end - 1);
+    }
+
+    public static double getDoubleFromJson(String raw, String key) {
+        String val = getNumberPartFromJson(raw, key);
+        return Double.parseDouble(val);
+    }
+
+    private static String getStrArrStrFromJson(String raw, String key) {
+        int keyIdx = raw.indexOf(key);
+        if (keyIdx < 0) {
+            throw new IllegalStateException("couldn't find key in raw");
+        }
+        String rest = raw.substring(keyIdx + key.length() + 4);
+        int end = rest.indexOf("],") > 0 ? rest.indexOf("],") : rest.indexOf("]}");
+        return rest.substring(0, end);
+    }
+
+    public static String[] getPlayerPartsFromJson(String raw) {
+        String key = "players";
+        int keyIdx = raw.indexOf(key);
+        if (keyIdx < 0) {
+            throw new IllegalStateException("couldn't find key in raw");
+        }
+        String rest = raw.substring(keyIdx + key.length() + 5);
+        int end = rest.indexOf("]],") > 0 ? rest.indexOf("]],") : rest.indexOf("]]}");
+        return rest.substring(0, end).split("], \\[");
+    }
+
+    public static String[] getStrArrFromJson(String raw, String key) {
+        String arrStr = getStrArrStrFromJson(raw, key);
+        return arrStr.split(", ");
+    }
+
+    public static int[] getIntArrFromJson(String raw, String key) {
+        String[] arrStrParts = getStrArrStrFromJson(raw, key).split(", ");
+        int[] intArr = new int[arrStrParts.length];
+        for (int i = 0; i < arrStrParts[i].length(); i++) {
+            intArr[i] = Integer.parseInt(arrStrParts[i]);
+        }
+        return intArr;
+    }
+
+    public static double[] getDoubleArrFromJson(String raw, String key) {
+        String[] arrStrParts = getStrArrStrFromJson(raw, key).split(", ");
+        double[] doubleArr = new double[arrStrParts.length];
+        for (int i = 0; i < arrStrParts[i].length(); i++) {
+            doubleArr[i] = Double.parseDouble(arrStrParts[i]);
+        }
+        return doubleArr;
+    }
+    
+    public static boolean containsKey(String raw, String key) {
+        return raw.indexOf(key) > -1;
+    }
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Observation.java

@@ -0,0 +1,72 @@
+package kore;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class Observation {
+    public final double[] kore;
+    public final double[] playerHlt; 
+    public final ArrayList<HashMap<String, int[]>> playerShipyards;
+    public final ArrayList<HashMap<String, String[]>> playerFleets;
+    public final int player;
+    public final int step;
+    public final double remainingOverageTime;
+
+    private static String shortenFrontAndBack(String target, int n) {
+        return target.substring(n, target.length() - n);
+    }
+
+    public Observation(String rawObservation) {
+        // avoid importing json library? worth it?
+        this.kore = KoreJson.getDoubleArrFromJson(rawObservation, "kore");
+        this.player = KoreJson.getPlayerIdxFromJson(rawObservation);
+        this.step = KoreJson.getIntFromJson(rawObservation, "step");
+        this.remainingOverageTime = KoreJson.getDoubleFromJson(rawObservation, "remainingOverageTime");
+        String[] playerParts = KoreJson.getPlayerPartsFromJson(rawObservation);
+        playerHlt = new double[playerParts.length];
+        playerShipyards = new ArrayList<HashMap<String, int[]>>();
+        playerFleets = new ArrayList<HashMap<String, String[]>>();
+
+        for (int i = 0; i < playerParts.length; i ++) {
+            String playerPart = playerParts[i];
+            playerHlt[i] = Double.parseDouble(playerPart.split(", ")[0]);
+
+            int startShipyards = playerPart.indexOf("{");
+            int endShipyards = playerPart.indexOf("}");
+            String shipyardsStr = playerPart.substring(startShipyards + 1, endShipyards - 1);
+            HashMap<String, int[]> shipyards = new HashMap<String, int[]>();
+            Arrays.stream(shipyardsStr.split("], ")).forEach(shipyardStr -> {
+                if (shipyardStr.length() == 0) {
+                    return;
+                }
+                String[] kvparts = shipyardStr.split(": \\[");
+                String shipyardId = shortenFrontAndBack(kvparts[0], 1);
+                String[] shipyardStrs = kvparts[1].split(", ");
+                int[] shipyard = new int[shipyardStrs.length];
+                Integer[] shipyardInts = Arrays.stream(shipyardStrs).map(s -> Integer.parseInt(s)).toArray(Integer[]::new);
+                for(int j = 0; j < shipyard.length; j++) {
+                    shipyard[j] = shipyardInts[j];
+                }
+                shipyards.put(shipyardId, shipyard);
+            });
+            playerShipyards.add(shipyards);
+
+            int startFleets = playerPart.indexOf("}, ");
+            String fleetsStr = playerPart.substring(startFleets + 4, playerPart.length() - 1);
+            HashMap<String, String[]> fleets = new HashMap<>();
+            Arrays.stream(fleetsStr.split("], ")).forEach(fleetStr -> {
+                if (fleetStr.length() == 0) {
+                    return;
+                }
+                String[] kvparts = fleetStr.split(": ");
+                String fleetId = shortenFrontAndBack(kvparts[0], 1);
+                String[] fleet = shortenFrontAndBack(kvparts[1], 1).split(", ");
+                fleets.put(fleetId, fleet);
+            });
+            playerFleets.add(fleets);
+        }
+    }
+
+    
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Pair.java

@@ -0,0 +1,13 @@
+package kore;
+
+public class Pair<F, S> {
+
+    public final F first;
+    public final S second;
+
+    public Pair(F first, S second) {
+        this.first = first;
+        this.second = second;
+    }
+    
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Player.java

@@ -0,0 +1,68 @@
+package kore;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.stream.Collectors;
+
+public class Player {
+    public final int id; 
+    public double kore; 
+    public final ArrayList<String> shipyardIds; 
+    public final ArrayList<String> fleetIds;
+    public final Board board;
+    
+    public Player(int playerId, double kore, ArrayList<String> shipyardIds, ArrayList<String> fleetIds, Board board) {
+        this.id = playerId;
+        this.kore = kore;
+        this.shipyardIds = shipyardIds;
+        this.fleetIds = fleetIds;
+        this.board = board;
+    }
+
+    public Player cloneToBoard(Board board) {
+        return new Player(this.id, this.kore, new ArrayList<String>(this.shipyardIds.stream().collect(Collectors.toList())), new ArrayList<String>(this.fleetIds.stream().collect(Collectors.toList())), board);
+    }
+
+    /**
+     * Returns all shipyards owned by this player.
+     * @return
+     */
+    public Shipyard[] shipyards() {
+        return this.board.shipyards.values().stream().filter(shipyard -> this.shipyardIds.stream().anyMatch(sId -> sId == shipyard.id)).toArray(Shipyard[]::new);
+    }
+
+    /**
+     * Returns all fleets owned by this player.
+     */
+    public Fleet[] fleets() {
+        return this.board.fleets.values().stream().filter(fleet -> this.fleetIds.stream().anyMatch(fId -> fId == fleet.id)).toArray(Fleet[]::new);
+    }
+
+    /**
+     * Returns whether this player is the current player (generally if this returns True, this player is you.
+     */
+    public boolean isCurrentPlayer() {
+        return this.id == this.board.currentPlayerId;
+    }
+
+    /**
+     * Returns all queued fleet and shipyard actions for this player formatted for the kore interpreter to receive as an agent response.
+     */
+    public HashMap<String, ShipyardAction> nextActions() {
+        HashMap<String, ShipyardAction> result = new HashMap<>();
+        Arrays.stream(this.shipyards()).filter(shipyard -> shipyard.nextAction.isPresent()).forEach(shipyard -> result.put(shipyard.id, shipyard.nextAction.get()));
+        return result;
+    }
+
+    /**
+     * Converts a player back to the normalized observation subset that constructed it.
+     */
+    public Object[] observation() {
+        HashMap<String, int[]> shipyards = new HashMap<>(); 
+        Arrays.stream(this.shipyards()).forEach(shipyard -> shipyards.put(shipyard.id, shipyard.observation()));
+        HashMap<String, String[]> fleets = new HashMap<>();
+        Arrays.stream(this.fleets()).forEach(fleet -> fleets.put(fleet.id, fleet.observation()));
+        return new Object[]{this.kore, shipyards, fleets};
+    }
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Point.java

@@ -0,0 +1,65 @@
+package kore;
+
+public class Point {
+    public final int x, y;
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Point translate(Point offset, int size) {
+        return this.add(offset).mod(size);
+    }
+
+    public Point add(Point other) {
+        return new Point(this.x + other.x, this.y + other.y);
+    }
+
+    public Point mod(int size) {
+        return new Point(this.x % size, this.y % size);
+    }
+
+    /**
+     * Gets the manhatten distance between two points
+     */
+    public int distanceTo(Point other, int size) {
+        int abs_x = Math.abs(this.x - other.x);
+        int dist_x = abs_x < size/2 ? abs_x : size - abs_x;
+        int abs_y = Math.abs(this.y - other.y);
+        int dist_y = abs_y < size/2 ? abs_y : size - abs_y;
+        return dist_x + dist_y;
+    }
+
+    /**
+     * Converts a 2d position in the form (x, y) to an index in the observation.kore list.
+     * See fromIndex for the inverse.
+     */
+    public int toIndex(int size) {
+        return (size - this.y - 1) * size + this.x;
+    }
+
+    public static Point fromIndex(int index, int size) {
+        return new Point(index % size, size - index/size - 1);
+    }
+
+    public Point abs() {
+        return new Point(Math.abs(this.x), Math.abs(this.y));
+    }
+
+    public boolean equals(Point other) {
+        return this.x == other.x && this.y == other.y;
+    }
+
+    public String toString() {
+        return "(" + this.x + "," + this.y + ")";
+    }
+
+    public Point multiply(int factor) {
+        return new Point(factor * this.x, factor * this.y);
+    }
+
+    public Point subtract(Point other) {
+        return new Point(this.x - other.x, this.y - other.y);
+    }
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/Shipyard.java

@@ -0,0 +1,70 @@
+package kore;
+
+import java.util.Optional;
+
+public class Shipyard {
+    public final String id; 
+    public int shipCount; 
+    public Point position; 
+    public int playerId; 
+    public int turnsControlled; 
+    public final Board board; 
+    public Optional<ShipyardAction> nextAction;
+    private final int[] SPAWN_VALUES;
+    
+    public Shipyard(String shipyardId, int shipCount, Point position, int playerId, int turnsControlled, Board board, Optional<ShipyardAction> nextAction) {
+        this.id = shipyardId;
+        this.shipCount = shipCount;
+        this.position = position;
+        this.playerId = playerId;
+        this.turnsControlled = turnsControlled;
+        this.board = board;
+        this.nextAction = nextAction;
+
+        int[] upgradeTimes = new int[9];
+        for(int i = 1; i < 10; i++) {
+            upgradeTimes[i-1] = (int) Math.pow(i, 2) + 1;
+        }
+        SPAWN_VALUES = new int[9];
+        int current = 0;
+        for(int i = 1; i < 10; i++) {
+            current += upgradeTimes[i-1];
+            SPAWN_VALUES[i-1] = current;
+        }
+    }
+
+    public Shipyard cloneToBoard(Board board) {
+        return new Shipyard(this.id, this.shipCount, this.position, this.playerId, this.turnsControlled, board, this.nextAction);
+    }
+
+    public void setNextAction(ShipyardAction action) {
+        this.nextAction = Optional.of(action);
+    }
+
+    public int maxSpawn() {
+        for (int i = 0; i < this.SPAWN_VALUES.length; i++) {
+            if (this.turnsControlled < this.SPAWN_VALUES[i]) {
+                return i + 1;
+            }
+        }
+        return this.SPAWN_VALUES.length + 1;
+    }
+
+    /**
+     *  Returns the cell this shipyard is on.
+     */
+    public Cell cell() {
+        return this.board.getCellAtPosition(this.position);
+    }
+
+    public Player player() {
+        return this.board.players[this.playerId];
+    }
+   
+    /**
+     * Converts a shipyard back to the normalized observation subset that constructed it.
+     */
+    public int[] observation() {
+        return new int[]{this.position.toIndex(this.board.configuration.size), this.shipCount, this.turnsControlled};
+    }
+}

kaggle_environments/envs/kore_fleets/starter_bots/java/kore/ShipyardAction.java

@@ -0,0 +1,59 @@
+package kore;
+
+public class ShipyardAction {
+    public static final String SPAWN = "SPAWN";
+    public static final String LAUNCH = "LAUNCH";
+    public final String actionType;
+    public final int shipCount;
+    public final String flightPlan;
+
+    public static ShipyardAction spawnShips(int shipCount) {
+        return new ShipyardAction(SPAWN, shipCount, "");
+    }
+
+    public static ShipyardAction launchFleetWithFlightPlan(int shipCount, String flightPlan) {
+        return new ShipyardAction(LAUNCH, shipCount, flightPlan);
+    }
+
+    public static ShipyardAction fromString(String raw) {
+        if (raw.length() == 0) {
+            throw new IllegalStateException("invalid raw shipyard empty string");
+        }
+        int shipCount = Integer.parseInt(raw.split("_")[1]);
+        if (raw.startsWith(LAUNCH)) {
+            return ShipyardAction.spawnShips(shipCount);
+        }
+        if (raw.startsWith(SPAWN)) {
+            String flightPlan = raw.split("_")[2];
+            return ShipyardAction.launchFleetWithFlightPlan(shipCount, flightPlan);
+        }
+        throw new IllegalStateException("invalid Shipyard Action raw " + raw);
+    }
+
+    public ShipyardAction(String type, int shipCount, String flightPlan) {
+        assert type.equals(SPAWN) || type.equals(LAUNCH) : "Type must be SPAWN or LAUNCH";
+        assert shipCount >= 0 : "numShips must be a non-negative number";
+        this.actionType = type;
+        this.shipCount = shipCount;
+        this.flightPlan = flightPlan;
+    }
+
+    private boolean isSpawn() {
+        return this.actionType.equals(SPAWN);
+    }
+
+    private boolean isLaunch() {
+        return this.actionType.equals(LAUNCH);
+    }
+
+    public String toString() {
+        if (this.isSpawn()) {
+            return String.format("%s_%d", SPAWN, this.shipCount);
+        }
+        if (this.isLaunch()) {
+            return String.format("%s_%d_%s", LAUNCH, this.shipCount, this.flightPlan);
+        }
+        throw new IllegalStateException("invalid Shpyard Action");
+    }
+
+}