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

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

@@ -0,0 +1,169 @@
+import {Point} from "./Point";
+
+export class Direction extends Point {
+
+    public static readonly NORTH = new Direction(0, 1);
+    public static readonly EAST = new Direction(1, 0);
+    public static readonly SOUTH = new Direction(0, -1);
+    public static readonly WEST = new Direction(-1, 0);
+    
+    private constructor(x: number, y: number) {
+        super(x, y);
+    }
+
+    public equals(other: Direction): boolean {
+        return this.x == other.x && this.y == other.y;
+    }
+
+    public rotateLeft(): Direction {
+        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 Error("invalid direction");
+    }
+
+    public rotateRight(): Direction {
+        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 Error("invalid direction");
+    }
+
+    public opposite(): Direction {
+        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 Error("invalid direction");
+    }
+
+    public toChar(): string {
+        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 Error("invalid direction");
+    }
+
+    public toString(): string {
+        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 Error("invalid direction");
+    }
+
+    public toIndex(): number {
+        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 Error("invalid direction");
+    }
+
+    public static fromString(dirStr: string): Direction {
+        switch(dirStr) {
+            case "NORTH":
+                return Direction.NORTH;
+            case "EAST":
+                return Direction.EAST;
+            case "SOUTH":
+                return Direction.SOUTH;
+            case "WEST":
+                return Direction.WEST;
+        }
+        throw new Error("invalid direction");
+    }
+
+    public static fromChar(dirChar: string): Direction {
+        switch(dirChar) {
+            case 'N':
+                return Direction.NORTH;
+            case 'E':
+                return Direction.EAST;
+            case 'S':
+                return Direction.SOUTH;
+            case 'W':
+                return Direction.WEST;
+        }
+        throw new Error("invalid direction");
+    }
+
+    public static fromIndex(index: number): Direction {
+        switch(index) {
+            case 0:
+                return Direction.NORTH;
+            case 1:
+                return Direction.EAST;
+            case 2:
+                return Direction.SOUTH;
+            case 3:
+                return Direction.WEST;
+        }
+        throw new Error("invalid direction");
+    }
+
+    public static randomDirection(): Direction {
+        return Direction.fromIndex(Math.floor(Math.random() * 4));
+    }
+
+    public static listDirections(): Direction[] {
+        return [
+            Direction.NORTH,
+            Direction.EAST,
+            Direction.SOUTH,
+            Direction.WEST
+        ];
+    }
+
+}

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

@@ -0,0 +1,76 @@
+import {Board} from "./Board";
+import {Cell} from "./Cell";
+import {Direction} from "./Direction";
+import {Player} from "./Player";
+import {Point} from "./Point";
+
+export class Fleet {
+
+    public readonly id: string;
+    public shipCount: number;
+    public direction: Direction;
+    public position: Point;
+    public flightPlan: string;
+    public kore: number;
+    public readonly playerId: number;
+    public readonly board: Board;
+    
+    public constructor(fleetId: string, shipCount: number, direction: Direction, position: Point, kore: number, flightPlan: string, playerId: number, 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 cloneToBoard(board: Board): Fleet {
+        return new Fleet(this.id, this.shipCount, this.direction, this.position, this.kore, this.flightPlan, this.playerId, board);
+    }
+
+    public get cell(): Cell {
+        return this.board.getCellAtPosition(this.position);
+    }
+
+    public get player(): Player {
+        return this.board.players[this.playerId];
+    }
+
+    public get collectionRate(): number {
+        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 maxFlightPlanLenForShipCount(shipCount: number): number {
+        return (Math.floor(2 * Math.log(shipCount)) + 1);
+    }
+
+    /**
+     * Converts a fleet back to the normalized observation subset that constructed it.
+     */
+    public observation(): string[] {
+        return [
+            this.position.toIndex(this.board.configuration.size).toString(), 
+            this.kore.toString(),
+            this.shipCount.toString(),
+            this.direction.toIndex().toString(),
+            this.flightPlan
+        ];
+    }
+
+    public lessThanOtherAlliedFleet(other: Fleet): boolean {
+        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/ts/kore/KoreIO.ts

@@ -0,0 +1,70 @@
+import readline from 'readline';
+import { Board } from './Board';
+import { ShipyardAction } from './ShipyardAction';
+
+export class KoreIO {
+  public getLine: () => Promise<string>;
+
+  public _setup(): void {
+    // Prepare to read input
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: null,
+    });
+
+    const buffer = [];
+    let currentResolve: () => void;
+    let currentPromise;
+    const makePromise = function () {
+      return new Promise<void>((resolve) => {
+        currentResolve = resolve;
+      });
+    };
+    // on each line, push line to buffer
+    rl.on('line', (line) => {
+      buffer.push(line);
+      currentResolve();
+      currentPromise = makePromise();
+    });
+    // The current promise for retrieving the next line
+    currentPromise = makePromise();
+
+    // with await, we pause process until there is input
+    this.getLine = async () => {
+      return new Promise(async (resolve) => {
+        while (buffer.length === 0) {
+          // pause while buffer is empty, continue if new line read
+          await currentPromise;
+        }
+        // once buffer is not empty, resolve the most recent line in stdin, and remove it
+        resolve(buffer.shift());
+      });
+    };
+  }
+
+  /**
+   * Constructor for a new agent
+   * User should edit this according to the `Design` this agent will compete under
+   */
+  public constructor() {
+    this._setup(); // DO NOT REMOVE
+  }
+
+  public async run(loop: (board: Board) => Promise<Board>): Promise<void> {
+    while (true) {
+      const rawObservation = await this.getLine();
+      const rawConfiguration = await this.getLine();
+      const board = Board.fromRaw(rawObservation, rawConfiguration);
+      try {
+        const nextBoard = await loop(board);
+        let actions = [];
+        board.currentPlayer.nextActions.forEach((action: ShipyardAction, id: string) =>
+          actions.push(`${id}:${action.toString()}`)
+        );
+        console.log(actions.join(','));
+      } catch (err) {
+        console.log(err);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+
+export class Observation {
+    public readonly kore: number[];
+    public readonly playerHlt: number[]; 
+    public readonly playerShipyards: Map<string, number[]>[];
+    public readonly playerFleets: Map<string, string[]>[];
+    public readonly player: number;
+    public readonly step: number;
+    public readonly remainingOverageTime: number;
+
+    public constructor(rawObservation: string) {
+        const json = JSON.parse(rawObservation);
+        this.kore = json["kore"];
+        this.player = json["player"];
+        this.step = json["step"];
+        this.remainingOverageTime = rawObservation["remainingOverageTime"];
+        const playerParts = json["players"];
+        this.playerHlt = [];
+        this.playerShipyards = [];
+        this.playerFleets = [];
+
+        for (var i = 0; i < playerParts.length; i ++) {
+            const playerPart = playerParts[i];
+            this.playerHlt.push(parseInt(playerPart[0]));
+
+            const shipyards = new Map<string, number[]>();
+            Object.entries(playerPart[1]).forEach(entry => {
+                const shipyardId = entry[0];
+                const shipyardInts = entry[1];
+                shipyards.set(shipyardId, shipyardInts as number[]);
+            });
+            this.playerShipyards.push(shipyards);
+
+            const fleets = new Map<string, string[]>();
+            Object.entries(playerPart[2]).forEach(entry => {
+                const fleetId = entry[0];
+                const fleetStrs = entry[1];
+                fleets.set(fleetId, fleetStrs as string[])
+            })
+            this.playerFleets.push(fleets)
+        }
+    }
+
+    
+}

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

@@ -0,0 +1,11 @@
+export class Pair<F, S> {
+
+    public readonly first: F;
+    public readonly second: S;
+
+    public constructor(first: F, second: S) {
+        this.first = first;
+        this.second = second;
+    }
+    
+}

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

@@ -0,0 +1,68 @@
+import {Board} from "./Board";
+import {Fleet} from "./Fleet";
+import {Shipyard} from "./Shipyard";
+import {ShipyardAction} from "./ShipyardAction";
+
+export class Player {
+    public readonly id: number; 
+    public kore: number; 
+    public readonly shipyardIds: string[]; 
+    public readonly fleetIds: string[];
+    public readonly board: Board;
+    
+    public constructor(playerId: number, kore: number, shipyardIds: string[], fleetIds: string[], board: Board) {
+        this.id = playerId;
+        this.kore = kore;
+        this.shipyardIds = shipyardIds;
+        this.fleetIds = fleetIds;
+        this.board = board;
+    }
+
+    public cloneToBoard(board: Board): Player {
+        return new Player(this.id, this.kore, this.shipyardIds.slice(), this.fleetIds.slice(), board);
+    }
+
+    /**
+     * Returns all shipyards owned by this player.
+     * @return
+     */
+    public get shipyards(): Shipyard[] {
+        return Array.from(this.board.shipyards.values())
+            .filter(shipyard => this.shipyardIds.some(sId => sId == shipyard.id));
+    }
+
+    /**
+     * Returns all fleets owned by this player.
+     */
+    public get fleets(): Fleet[] {
+        return Array.from(this.board.fleets.values())
+            .filter(fleet => this.fleetIds.some(fId => fId == fleet.id));
+    }
+
+    /**
+     * Returns whether this player is the current player (generally if this returns True, this player is you.
+     */
+    public isCurrentPlayer(): boolean {
+        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 get nextActions(): Map<String, ShipyardAction> {
+        const result = new Map<String, ShipyardAction>();
+        this.shipyards.filter(shipyard => shipyard.nextAction).forEach(shipyard => result.set(shipyard.id, shipyard.nextAction as ShipyardAction));
+        return result;
+    }
+
+    /**
+     * Converts a player back to the normalized observation subset that constructed it.
+     */
+    public observation(): any[] {
+        const shipyards = new Map<string, number[]>(); 
+        this.shipyards.forEach(shipyard => shipyards.set(shipyard.id, shipyard.observation()));
+        const fleets = new Map<string, string[]>();
+        this.fleets.forEach(fleet => fleets.set(fleet.id, fleet.observation()));
+        return [this.kore, shipyards, fleets];
+    }
+}

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

@@ -0,0 +1,65 @@
+export class Point {
+    public readonly x: number; 
+    public readonly y: number;
+
+    public constructor(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public  translate(offset: Point, size: number): Point {
+        return this.add(offset).mod(size);
+    }
+
+    public  add(other: Point): Point {
+        return new Point(this.x + other.x, this.y + other.y);
+    }
+
+    public mod(size: number): Point {
+        // handle cases where the point is negative due to translation offset being negative
+        return new Point((this.x + size) % size, (this.y + size) % size);
+    }
+
+    /**
+     * Gets the manhatten distance between two points
+     */
+    public distanceTo(other: Point, size: number): number {
+        const abs_x = Math.abs(this.x - other.x);
+        const dist_x = abs_x < size/2 ? abs_x : size - abs_x;
+        const abs_y = Math.abs(this.y - other.y);
+        const 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 toIndex(size: number) {
+        return (size - this.y - 1) * size + this.x;
+    }
+
+    public static fromIndex(index: number, size: number): Point {
+        return new Point(index % size, size - Math.floor(index/size) - 1);
+    }
+
+    public abs(): Point {
+        return new Point(Math.abs(this.x), Math.abs(this.y));
+    }
+
+    public equals(other: Point): boolean {
+        return this.x == other.x && this.y == other.y;
+    }
+
+    public toString(): string {
+        return "(" + this.x + "," + this.y + ")";
+    }
+
+    public multiply(factor: number): Point {
+        return new Point(factor * this.x, factor * this.y);
+    }
+
+    public subtract(other: Point): Point {
+        return new Point(this.x - other.x, this.y - other.y);
+    }
+}

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

@@ -0,0 +1,72 @@
+
+import {Board} from "./Board";
+import {Cell} from "./Cell";
+import {Player} from "./Player";
+import {Point} from "./Point";
+import {ShipyardAction} from "./ShipyardAction";
+
+const SPAWN_VALUES = [];
+const upgradeTimes: number[] = [];
+for(let i = 1; i < 10; i++) {
+    upgradeTimes[i-1] = Math.pow(i, 2) + 1;
+}
+let current = 0;
+for(let i = 1; i < 10; i++) {
+    current += upgradeTimes[i-1];
+    SPAWN_VALUES[i-1] = current;
+}
+
+export class Shipyard {
+    public readonly id: string; 
+    public shipCount: number; 
+    public position: Point; 
+    public playerId: number; 
+    public turnsControlled: number; 
+    public readonly board: Board; 
+    public nextAction: ShipyardAction | undefined;
+    
+    public constructor(shipyardId: string, shipCount: number, position: Point, playerId: number, turnsControlled: number, board: Board, nextAction: ShipyardAction | undefined) {
+        this.id = shipyardId;
+        this.shipCount = shipCount;
+        this.position = position;
+        this.playerId = playerId;
+        this.turnsControlled = turnsControlled;
+        this.board = board;
+        this.nextAction = nextAction;
+    }
+
+    public cloneToBoard(board: Board): Shipyard {
+        return new Shipyard(this.id, this.shipCount, this.position, this.playerId, this.turnsControlled, board, this.nextAction);
+    }
+
+    public setNextAction(action: ShipyardAction): void {
+        this.nextAction = action;
+    }
+
+    public get maxSpawn(): number {
+        for (let i = 0; i < SPAWN_VALUES.length; i++) {
+            if (this.turnsControlled < SPAWN_VALUES[i]) {
+                return i + 1;
+            }
+        }
+        return SPAWN_VALUES.length + 1;
+    }
+
+    /**
+     *  Returns the cell this shipyard is on.
+     */
+    public get cell(): Cell {
+        return this.board.getCellAtPosition(this.position);
+    }
+
+    public get player(): Player {
+        return this.board.players[this.playerId];
+    }
+   
+    /**
+     * Converts a shipyard back to the normalized observation subset that constructed it.
+     */
+    public observation(): number[] {
+        return [this.position.toIndex(this.board.configuration.size), this.shipCount, this.turnsControlled];
+    }
+}

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

@@ -0,0 +1,58 @@
+
+export class ShipyardAction {
+    public static readonly SPAWN = "SPAWN";
+    public static readonly LAUNCH = "LAUNCH";
+    public readonly actionType: string;
+    public readonly shipCount: number;
+    public readonly flightPlan: string;
+
+    public static spawnShips(shipCount: number): ShipyardAction {
+        return new ShipyardAction(ShipyardAction.SPAWN, shipCount, "");
+    }
+
+    public static launchFleetWithFlightPlan(shipCount: number, flightPlan: string): ShipyardAction {
+        return new ShipyardAction(ShipyardAction.LAUNCH, shipCount, flightPlan);
+    }
+
+    public static fromstring(raw: string): ShipyardAction {
+        if (raw.length == 0) {
+            throw new Error("invalid raw shipyard empty string");
+        }
+        const shipCount = parseInt(raw.split("_")[1]);
+        if (raw.startsWith(ShipyardAction.LAUNCH)) {
+            return ShipyardAction.spawnShips(shipCount);
+        }
+        if (raw.startsWith(ShipyardAction.SPAWN)) {
+            const flightPlan = raw.split("_")[2];
+            return ShipyardAction.launchFleetWithFlightPlan(shipCount, flightPlan);
+        }
+        throw new Error("invalid Shipyard Action raw " + raw);
+    }
+
+    public constructor(type: string, shipCount: number, flightPlan: string) {
+        // 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 get isSpawn(): boolean {
+        return this.actionType == ShipyardAction.SPAWN;
+    }
+
+    private get isLaunch(): boolean {
+        return this.actionType == ShipyardAction.LAUNCH;
+    }
+
+    public toString(): string {
+        if (this.isSpawn) {
+            return `${ShipyardAction.SPAWN}_${this.shipCount}`;
+        }
+        if (this.isLaunch) {
+            return `${ShipyardAction.LAUNCH}_${this.shipCount}_${this.flightPlan}`;
+        }
+        throw new Error("invalid Shpyard Action");
+    }
+
+}