Merge pull request #152 from stoianchoo/master

TypeScript starter kit

Author: lidavidm

starter_kits/TypeScript/.gitignore

@@ -0,0 +1,4 @@
+*.hlt
+*.log
+*~ts
+/out/*

starter_kits/TypeScript/MyBot.ts

@@ -0,0 +1,59 @@
+import { Constants } from "./hlt/Constants";
+import { Direction } from "./hlt/Direction";
+import { Game } from "./hlt/Game";
+import { Logging } from "./hlt/Logging";
+import { Random } from "./hlt/Random";
+
+const firstArgument = process.argv[2];
+const random = new Random(firstArgument ? Number(firstArgument) : 324231);
+
+const game = new Game();
+game.initialize().then(async ([gameMap, me]) => {
+    // At this point "game" variable is populated with initial map data.
+    // This is a good place to do computationally expensive start-up pre-processing.
+    // As soon as you call "ready" function below, the 2 second per turn timer will start.
+    await game.ready("MyTypeScriptBot");
+
+    Logging.info(`My Player ID is ${game.myId}.`);
+
+    while (true) {
+        await game.updateFrame();
+
+        const commandQueue = [];
+
+        // Movement algorithm parameters
+        const fullCargoCoefficient = 0.5;
+        const tooLittleHaliteToKeepHarvestingCoefficient = 0.1;
+        const spawnNewShipsUntilGameTurnCoefficient = 0.75;
+
+        for (const ship of me.getShips()) {
+            if (ship.haliteAmount > fullCargoCoefficient * Constants.MAX_ENERGY) {
+                // Go home if full
+                const destination = me.shipyard.position;
+                const safeMove = gameMap.naiveNavigate(ship, destination);
+                commandQueue.push(ship.move(safeMove));
+            } else if (
+                gameMap.get(ship.position).haliteAmount <
+                tooLittleHaliteToKeepHarvestingCoefficient * Constants.MAX_ENERGY
+            ) {
+                // Go harvest to a new place
+                const getRandomArrayElement = (anArray: any[]) => anArray[Math.floor(anArray.length * random.next())];
+                const direction = getRandomArrayElement(Direction.getAllCardinals());
+                const destination = ship.position.directionalOffset(direction);
+                const safeMove = gameMap.naiveNavigate(ship, destination);
+                commandQueue.push(ship.move(safeMove));
+            } else {
+                // Keep still and harvest in place
+            }
+        }
+
+        if (game.turnNumber < spawnNewShipsUntilGameTurnCoefficient * Constants.MAX_TURNS &&
+            // Spawn new ships
+            me.haliteAmount >= Constants.SHIP_COST &&
+            !gameMap.get(me.shipyard).isOccupied) {
+            commandQueue.push(me.shipyard.spawn());
+        }
+
+        await game.endTurn(commandQueue);
+    }
+});

starter_kits/TypeScript/README.md

@@ -0,0 +1,5 @@
+# Setup
+Run `npm install` to locally install the required dependencies before developing.
+
+# Development
+The `run_game` scripts will run `tslint` and `tsc` to proof and compile the typescript sources before running the bot.

starter_kits/TypeScript/hlt/Direction.ts

@@ -0,0 +1,56 @@
+import { Commands } from "./Commands";
+
+export class Direction {
+    public static North = new Direction(0, -1);
+    public static South = new Direction(0, 1);
+    public static East = new Direction(1, 0);
+    public static West = new Direction(-1, 0);
+    public static Still = new Direction(0, 0);
+
+    public static getAllCardinals() {
+        return [ Direction.North, Direction.South, Direction.East, Direction.West ];
+    }
+
+    constructor(public dx: number, public dy: number) {
+        this.dx = dx;
+        this.dy = dy;
+    }
+
+    public equals(other: Direction) {
+        return this.dx === other.dx && this.dy === other.dy;
+    }
+
+    public toString() {
+        return `${this.constructor.name}(${this.dx}, ${this.dy})`;
+    }
+
+    public toWireFormat() {
+        if (this.equals(Direction.North)) {
+            return Commands.NORTH;
+        } else if (this.equals(Direction.South)) {
+            return Commands.SOUTH;
+        } else if (this.equals(Direction.East)) {
+            return Commands.EAST;
+        } else if (this.equals(Direction.West)) {
+            return Commands.WEST;
+        } else if (this.equals(Direction.Still)) {
+            return Commands.STAY_STILL;
+        }
+        throw new Error(`Non-cardinal direction cannot be converted to wire format: ${this}`);
+    }
+
+    public invert() {
+        if (this.equals(Direction.North)) {
+            return Direction.South;
+        } else if (this.equals(Direction.South)) {
+            return Direction.North;
+        } else if (this.equals(Direction.East)) {
+            return Direction.West;
+        } else if (this.equals(Direction.West)) {
+            return Direction.East;
+        } else if (this.equals(Direction.Still)) {
+            return Direction.Still;
+        }
+        throw new Error(`Non-cardinal direction cannot be inverted: ${this}`);
+    }
+}

starter_kits/TypeScript/hlt/Dropoff.ts

@@ -0,0 +1,5 @@
+import { Entity } from "./entity";
+
+/** Represents a dropoff. */
+export class Dropoff extends Entity {
+}

starter_kits/TypeScript/hlt/Game.ts

@@ -0,0 +1,117 @@
+import { Dropoff } from "./Dropoff";
+import { GameMap } from "./GameMap";
+import { Logging } from "./Logging";
+import { Player } from "./Player";
+import { Position } from "./Position";
+import { ServerCommunication } from "./ServerCommunicaion";
+import { Ship } from "./Ship";
+import { Shipyard } from "./Shipyard";
+
+export class Game {
+    public turnNumber = 0;
+    public server: ServerCommunication = new ServerCommunication();
+
+    public myId = 0;
+    public players = new Map<number, Player>();
+    public me?: Player;
+    public gameMap?: GameMap;
+
+    /**
+     * Initialize a game object collecting all the start-state
+     * instances for pre-game. Also sets up a log file in
+     * "bot-<bot_id>.log".
+     * @returns The initialized gameMap and me so we don't have to check if undefined.
+     */
+    public async initialize(): Promise<[GameMap, Player]> {
+        const serverData = await this.server.getInitialData();
+        this.myId = serverData.myId;
+
+        Logging.setup(`bot-${this.myId}.log`);
+
+        serverData.players.forEach((playerData) => {
+            const player = new Player(playerData.id,
+                new Shipyard(playerData.id, -1, new Position(playerData.x, playerData.y)));
+            this.players.set(player.id, player);
+        });
+        this.me = this.players.get(this.myId);
+
+        this.gameMap = new GameMap(serverData.cells);
+
+        return [this.gameMap as GameMap, this.me as Player]; // We cast here because we have just initialized
+    }
+
+    /**
+     * Updates the game object's state.
+     */
+    public async updateFrame() {
+        const data = await this.server.getUpdateData(this.players.size);
+        this.turnNumber = data.turn;
+        Logging.info(`================ TURN ${this.turnNumber.toString().padStart(3, "0")} ================`);
+        data.players.forEach((playerData) => {
+            const player = this.players.get(playerData.id) as Player;
+            player.haliteAmount = playerData.halite;
+
+            // Process ships
+            const newShipsData = playerData.ships
+                .filter((shipData) => !player.hasShip(shipData.id));
+            newShipsData.forEach((newShipData) =>
+                player.addShip(new Ship(player.id, newShipData.id,
+                    new Position(newShipData.x, newShipData.y), newShipData.halite)));
+
+            const lostShips = player.getShips()
+                .filter((ship) => !playerData.ships.some((shipData) => shipData.id === ship.id));
+            lostShips.forEach((ship) => player.loseShip(ship.id));
+
+            player.getShips().forEach((ship) => {
+                const updatedShipData = playerData.ships
+                    .find((shipData) => ship.id === shipData.id);
+                if (updatedShipData) {
+                    [ship.haliteAmount, ship.position.x, ship.position.y] =
+                        [updatedShipData.halite, updatedShipData.x, updatedShipData.y];
+                }
+            });
+
+            // Process dropoffs
+            const newDropoffsData = playerData.dropoffs
+                .filter((dropoffData) => !player.dropoffs.has(dropoffData.id));
+            newDropoffsData.forEach((newDropoffData: { id: number, x: number, y: number }) =>
+                player.dropoffs.set(newDropoffData.id,
+                    new Dropoff(player.id, newDropoffData.id, new Position(newDropoffData.x, newDropoffData.y))));
+
+            const lostDropoffs = Array.from(player.dropoffs.values())
+                .filter((dropoff) => !playerData.dropoffs.some((dropoffData) => dropoffData.id === dropoff.id));
+            lostDropoffs.forEach((lostDropoff) => {
+                player.dropoffs.delete(lostDropoff.id);
+                player.lostDropoffs.set(lostDropoff.id, lostDropoff);
+            });
+        });
+
+        const gameMap = this.gameMap as GameMap;
+        // Mark all cells as safe
+        gameMap.cells.forEach((row) => row.forEach((cell) => cell.markSafe()));
+        // Update cells
+        data.cells.forEach((cell) => gameMap.get(new Position(cell.x, cell.y)).haliteAmount = cell.halite);
+        // Mark cells with ships as unsafe for navigation, mark sturctures
+        for (const player of this.players.values()) {
+            player.getShips()
+                .forEach((ship) => gameMap.get(ship.position).markUnsafe(ship));
+            player.getDropoffs()
+                .forEach((dropoff) => gameMap.get(dropoff.position).structure = dropoff);
+        }
+    }
+
+    /**
+     * Indicate that your bot is ready to play by sending the bot name.
+     */
+    public async ready(botName: string) {
+        await this.server.sendCommands([botName]);
+    }
+
+    /**
+     * Send all commands to the game engine, effectively ending your
+     * turn.
+     */
+    public async endTurn(commands: string[]) {
+        await this.server.sendCommands(commands);
+    }
+}

starter_kits/TypeScript/hlt/MapCell.ts

@@ -0,0 +1,53 @@
+import { Dropoff } from "./Dropoff";
+import { Position } from "./Position";
+import { Ship } from "./Ship";
+import { Shipyard } from "./Shipyard";
+
+/** A cell on the game map. */
+export class MapCell {
+    public ship?: Ship;
+    public structure?: Shipyard | Dropoff;
+
+    constructor(public position: Position, public haliteAmount: number) {
+    }
+
+    /**
+     * Whether this cell has no ships or structures.
+     */
+    get isEmpty() {
+        return !this.isOccupied && !this.hasStructure;
+    }
+
+    /**
+     * Whether this cell has any ships.
+     */
+    get isOccupied() {
+        return this.ship !== undefined;
+    }
+
+    /**
+     * Whether this cell has any structures.
+     */
+    get hasStructure() {
+        return this.structure !== undefined;
+    }
+
+    /**
+     * Mark this cell as unsafe (occupied) for navigation.
+     */
+    public markUnsafe(ship: Ship) {
+        this.ship = ship;
+    }
+
+    public markSafe() {
+        this.ship = undefined;
+    }
+
+    public equals(other: MapCell) {
+        return this.position.equals(other.position);
+    }
+
+    public toString() {
+        return `MapCell(${this.position}, halite=${this.haliteAmount})`;
+    }
+}

starter_kits/TypeScript/hlt/Player.ts

@@ -0,0 +1,51 @@
+import { Dropoff } from "./Dropoff";
+import { Ship } from "./Ship";
+import { Shipyard } from "./Shipyard";
+
+/** Player object, containing all entities/metadata for the player. */
+export class Player {
+    public ships = new Map<number, Ship>();
+    public lostShips = new Map<number, Ship>();
+    public dropoffs = new Map<number, Dropoff>();
+    public lostDropoffs = new Map<number, Dropoff>();
+    constructor(public id: number, public shipyard: Shipyard, public haliteAmount = 0) {
+    }
+
+    /** Get a single ship by its ID. */
+    public getShip(shipId: number) {
+        return this.ships.get(shipId);
+    }
+
+    /** Get a list of the player's ships. */
+    public getShips() {
+        return Array.from(this.ships.values());
+    }
+
+    /** Get a single dropoff by its ID. */
+    public getDropoff(dropoffId: number) {
+        return this.dropoffs.get(dropoffId);
+    }
+
+    /** Get a list of the player's dropoffs. */
+    public getDropoffs() {
+        return Array.from(this.dropoffs.values());
+    }
+
+    /** Check whether a ship with a given ID exists. */
+    public hasShip(shipId: number) {
+        return this.ships.has(shipId);
+    }
+
+    /**
+     * Remove ship from the ships list and add it to the lostShips list
+     * to keep the ship state even when lost.
+     */
+    public loseShip(shipId: number) {
+        this.lostShips.set(shipId,  this.ships.get(shipId) as Ship);
+        this.ships.delete(shipId);
+    }
+
+    public addShip(ship: Ship) {
+        this.ships.set(ship.id, ship);
+    }
+}