Now is linted with tslint with recommended rules.

Added tslint to run_game scripts.
Updated readme about tslint.

Author: stoianchoo

starter_kits/TypeScript/MyBot.ts

@@ -1,8 +1,8 @@
-import { Constants } from './hlt/Constants';
-import { Direction } from './hlt/Direction';
-import { Logging } from './hlt/Logging';
-import { Game } from './hlt/Game';
-import { Random } from './hlt/Random';
+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);
@@ -12,7 +12,7 @@ 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');
+    await game.ready("MyTypeScriptBot");
 
     Logging.info(`My Player ID is ${game.myId}.`);
 
@@ -32,16 +32,17 @@ game.initialize().then(async ([gameMap, me]) => {
                 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) {
+            } 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 {
+            } else {
                 // Keep still and harvest in place
             }
         }

starter_kits/TypeScript/README.md

@@ -1,6 +1,6 @@
 # Setup
-You should have typescript installed before developing. You can do this globally with `npm install -g typescript`
+You should have typescript installed before developing. You can do this globally with `npm install -g tslint typescript`
 Run `npm install` to get the typescript definitions for node.
 
 # Development
-Don't forget to run `tsc` to compile the typescript sources before using the bot.
+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

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

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

starter_kits/TypeScript/hlt/Game.ts

@@ -1,15 +1,15 @@
-import { Logging } from "./Logging";
+import { Dropoff } from "./Dropoff";
 import { GameMap } from "./GameMap";
+import { Logging } from "./Logging";
 import { Player } from "./Player";
-import { Ship } from "./Ship";
 import { Position } from "./Position";
-import { Shipyard } from "./Shipyard";
-import { Dropoff } from "./Dropoff";
 import { ServerCommunication } from "./ServerCommunicaion";
+import { Ship } from "./Ship";
+import { Shipyard } from "./Shipyard";
 
 export class Game {
-    turnNumber = 0;
-    server: ServerCommunication = new ServerCommunication();
+    public turnNumber = 0;
+    public server: ServerCommunication = new ServerCommunication();
 
     public myId = 0;
     public players = new Map<number, Player>();
@@ -22,94 +22,96 @@ export class Game {
      * "bot-<bot_id>.log".
      * @returns The initialized gameMap and me so we don't have to check if undefined.
      */
-    async initialize(): Promise<[GameMap, Player]> {
+    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)))
+        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 [<GameMap>this.gameMap, <Player>this.me]; // We cast here because we have just initialized
+        return [this.gameMap as GameMap, this.me as Player]; // We cast here because we have just initialized
     }
 
     /**
      * Updates the game object's state.
      */
-    async updateFrame() {
+    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 = <Player>this.players.get(playerData.id);
+        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)));
+                .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));
+                .filter((ship) => !playerData.ships.some((shipData) => shipData.id === ship.id));
+            lostShips.forEach((ship) => player.loseShip(ship.id));
 
-            player.getShips().forEach(ship => {
+            player.getShips().forEach((ship) => {
                 const updatedShipData = playerData.ships
-                    .find(shipData => ship.id === shipData.id);
+                    .find((shipData) => ship.id === shipData.id);
                 if (updatedShipData) {
-                    [ship.haliteAmount, ship.position.x, ship.position.y] = [updatedShipData.halite, updatedShipData.x, updatedShipData.y];
+                    [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));
+                .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 => {
+                .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 = <GameMap>this.gameMap;
+        const gameMap = this.gameMap as GameMap;
         // Mark all cells as safe
-        gameMap.cells.forEach(row => row.forEach(cell => cell.markSafe()));
+        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);
+        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));
+                .forEach((ship) => gameMap.get(ship.position).markUnsafe(ship));
             player.getDropoffs()
-                .forEach(dropoff => gameMap.get(dropoff.position).structure = dropoff);
+                .forEach((dropoff) => gameMap.get(dropoff.position).structure = dropoff);
         }
     }
 
-    /** 
-     * Indicate that your bot is ready to play by sending the bot name. 
+    /**
+     * Indicate that your bot is ready to play by sending the bot name.
      */
-    async ready(botName: string) {
+    public async ready(botName: string) {
         await this.server.sendCommands([botName]);
     }
 
     /**
      * Send all commands to the game engine, effectively ending your
      * turn.
      */
-    async endTurn(commands: string[]) {
+    public async endTurn(commands: string[]) {
         await this.server.sendCommands(commands);
     }
 }
-

starter_kits/TypeScript/hlt/MapCell.ts

@@ -1,12 +1,12 @@
-import { Ship } from "./Ship";
+import { Dropoff } from "./Dropoff";
 import { Position } from "./Position";
+import { Ship } from "./Ship";
 import { Shipyard } from "./Shipyard";
-import { Dropoff } from "./Dropoff";
 
 /** A cell on the game map. */
 export class MapCell {
-    ship?: Ship;
-    structure?: Shipyard | Dropoff;
+    public ship?: Ship;
+    public structure?: Shipyard | Dropoff;
 
     constructor(public position: Position, public haliteAmount: number) {
     }
@@ -35,19 +35,19 @@ export class MapCell {
     /**
      * Mark this cell as unsafe (occupied) for navigation.
      */
-    markUnsafe(ship: Ship) {
+    public markUnsafe(ship: Ship) {
         this.ship = ship;
     }
 
-    markSafe() {
+    public markSafe() {
         this.ship = undefined;
     }
 
-    equals(other: MapCell) {
+    public equals(other: MapCell) {
         return this.position.equals(other.position);
     }
-    
-    toString() {
+
+    public toString() {
         return `MapCell(${this.position}, halite=${this.haliteAmount})`;
     }
-}
+}