kaggle-environments 0.2.0__py3-none-any.whl → 1.20.0__py3-none-any.whl

kaggle_environments/envs/lux_ai_2021/test_agents/js_simple/lux/map.js

@@ -0,0 +1,107 @@
+const GAME_CONSTANTS = require('./game_constants');
+const DIRECTIONS = GAME_CONSTANTS.DIRECTIONS;
+class GameMap {
+  constructor(width, height) {
+    this.height = height;
+    this.width = width;
+    this.map = new Array(this.height);
+
+    for (let y = 0; y < this.height; y++) {
+      this.map[y] = new Array(this.width);
+      for (let x = 0; x < this.width; x++) {
+        this.map[y][x] = new Cell(x, y);
+      }
+    }
+  }
+  getCellByPos(pos) {
+    return this.map[pos.y][pos.x];
+  }
+  getCell(x, y) {
+    return this.map[y][x];
+  }
+  _setResource(type, x, y, amount) {
+    const cell = this.getCell(x, y);
+    cell.resource = {
+      type: type,
+      amount: amount
+    }
+  }
+
+}
+
+class Cell {
+  constructor(x, y) {
+    this.pos = new Position(x, y);
+    this.resource = null;
+    this.citytile = null;
+    this.road = 0;
+  }
+  hasResource() {
+    return this.resource !== null && this.resource.amount > 0;
+  }
+}
+
+class Position {
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  isAdjacent(pos) {
+    const dx = this.x - pos.x;
+    const dy = this.y - pos.y;
+    if (Math.abs(dx) + Math.abs(dy) > 1) {
+      return false;
+    }
+    return true;
+  }
+  equals(pos) {
+    return this.x === pos.x && this.y === pos.y;
+  }
+
+  translate(direction, units) {
+    switch (direction) {
+      case DIRECTIONS.NORTH:
+        return new Position(this.x, this.y - units);
+      case DIRECTIONS.EAST:
+        return new Position(this.x + units, this.y);
+      case DIRECTIONS.SOUTH:
+        return new Position(this.x, this.y + units);
+      case DIRECTIONS.WEST:
+        return new Position(this.x - units, this.y);
+      case DIRECTIONS.CENTER:
+        return new Position(this.x, this.y);
+    }
+  }
+
+  /** Returns Manhattan distance to pos from this position */
+  distanceTo(pos) {
+    return Math.abs(pos.x - this.x) + Math.abs(pos.y - this.y);
+  }
+
+  /** Returns closest direction to targetPos, or null if staying put is best */
+  directionTo(targetPos) {
+    const checkDirections = [
+      DIRECTIONS.NORTH,
+      DIRECTIONS.EAST,
+      DIRECTIONS.SOUTH,
+      DIRECTIONS.WEST,
+    ];
+    let closestDirection = DIRECTIONS.CENTER;
+    let closestDist = this.distanceTo(targetPos);
+    checkDirections.forEach((dir) => {
+      const newpos = this.translate(dir, 1);
+      const dist = targetPos.distanceTo(newpos);
+      if (dist < closestDist) {
+        closestDist = dist;
+        closestDirection = dir;
+      }
+    });
+    return closestDirection;
+  }
+}
+
+module.exports = {
+  GameMap,
+  Cell,
+  Position,
+}

kaggle_environments/envs/lux_ai_2021/test_agents/js_simple/lux/parser.js

@@ -0,0 +1,79 @@
+/**
+ * Parser class to help parse a input line of data
+ */
+class Parser {
+  
+  constructor(d = ',') {
+    this.delimiter = d;
+    return this.parse.bind(this);
+  }
+  setDelimeter(s) {
+    this.delimiter = s;
+  }
+  parse(str) {
+    return new Parsed(str, this.delimiter);
+  }
+   
+}
+class Parsed {
+  constructor(str, d) {
+    this.str = str;
+    this.contents = str.split(d);
+    
+    // remove the last element if its empty string
+    if (this.contents[this.contents.length - 1] === '') {
+      this.contents = this.contents.slice(0, this.contents.length - 1);
+    }
+    this.index = 0;
+  }
+  _nextStr() {
+    if (this.index < this.contents.length) {
+      return this.contents[this.index++];
+    }
+    else {
+      throw new Error("No more contents to consume from line")
+    }
+  }
+  // Returns the remainder of the line as an array of integers
+  nextIntArr() {
+    if (this.index < this.contents.length) {
+      let remainder = this.contents.slice(this.index, this.contents.length).map((val) => parseInt(val));
+      return remainder;
+    }
+    else {
+      throw new Error("No more contents to consume from line")
+    }
+  }
+  nextInt() {
+    let str = this._nextStr();
+    return parseInt(str);
+  }
+  // Returns the remainder of the line as an array of floats
+  nextFloatArr() {
+    if (this.index < this.contents.length) {
+      let remainder = this.contents.slice(this.index++).map((val) => parseFloat(val));
+      return remainder;
+    }
+    else {
+      throw new Error("No more contents to consume from line")
+    }
+  }
+  nextFloat() {
+    let str = this._nextStr();
+    return parseFloat(str);
+  }
+  // Returns the remainder of the line as an array of strings
+  nextStrArr() {
+    if (this.index < this.contents.length) {
+      let remainder = this.contents.slice(this.index++);
+      return remainder;
+    }
+    else {
+      throw new Error("No more contents to consume from line")
+    }
+  }
+  nextStr() {
+    return this._nextStr();
+  }
+}
+module.exports = Parser

kaggle_environments/envs/lux_ai_2021/test_agents/js_simple/main.js

@@ -0,0 +1,88 @@
+const kit = require('./lux/kit');
+const GAME_CONSTANTS = require('./lux/game_constants');
+const DIRECTIONS = GAME_CONSTANTS.DIRECTIONS;
+// create a new agent
+const agent = new kit.Agent();
+const annotate = kit.annotate;
+
+// first initialize the agent, and then proceed to go in a loop waiting for updates and running the AI
+agent.initialize().then(async () => {
+  while (true) {
+    /** Do not edit! **/
+    // wait for updates
+    await agent.update();
+
+    const actions = [];
+    const gameState = agent.gameState;
+    /** AI Code Goes Below! **/
+
+    const player = gameState.players[gameState.id];
+    const opponent = gameState.players[(gameState.id + 1) % 2];
+    const gameMap = gameState.map;
+
+    const resourceTiles = [];
+    for (let y = 0; y < gameMap.height; y++) {
+      for (let x = 0; x < gameMap.width; x++) {
+        const cell = gameMap.getCell(x, y);
+        if (cell.hasResource()) {
+          resourceTiles.push(cell);
+        }
+      }
+    }
+
+    // we iterate over all our units and do something with them
+    for (let i = 0; i < player.units.length; i++) {
+      const unit = player.units[i];
+      if (unit.isWorker() && unit.canAct()) {
+        if (unit.getCargoSpaceLeft() > 0) {
+          // if the unit is a worker and we have space in cargo, lets find the nearest resource tile and try to mine it
+          let closestResourceTile = null;
+          let closestDist = 9999999;
+          resourceTiles.forEach((cell) => {
+            if (cell.resource.type === GAME_CONSTANTS.RESOURCE_TYPES.COAL && !player.researchedCoal()) return;
+            if (cell.resource.type === GAME_CONSTANTS.RESOURCE_TYPES.URANIUM && !player.researchedUranium()) return;
+            const dist = cell.pos.distanceTo(unit.pos);
+            if (dist < closestDist) {
+              closestDist = dist;
+              closestResourceTile = cell;
+            }
+          })
+          if (closestResourceTile != null) {
+            const dir = unit.pos.directionTo(closestResourceTile.pos);
+            // move the unit in the direction towards the closest resource tile's position.
+            actions.push(unit.move(dir));
+          }
+        } else {
+          // if unit is a worker and there is no cargo space left, and we have cities, lets return to them
+          if (player.cities.size > 0) {
+            const city = player.cities.values().next().value
+            let closestDist = 999999;
+            let closestCityTile = null;
+            
+            city.citytiles.forEach((citytile) => {
+              const dist = citytile.pos.distanceTo(unit.pos);
+              if (dist < closestDist) {
+                closestCityTile = citytile;
+                closestDist = dist;
+              }
+            });
+            if (closestCityTile != null) {
+              const dir = unit.pos.directionTo(closestCityTile.pos);
+              actions.push(unit.move(dir));
+            }
+          }
+        }
+      }
+    }
+
+    // you can add debug annotations using the functions in the annotate object
+    // actions.push(annotate.circle(0, 0))
+    
+    /** AI Code Goes Above! **/
+
+    /** Do not edit! **/
+    console.log(actions.join(","));
+    // end turn
+    agent.endTurn();
+    }
+});

kaggle_environments/envs/lux_ai_2021/test_agents/js_simple/main.py

@@ -0,0 +1,75 @@
+import atexit
+import os
+import sys
+from queue import Empty, Queue
+from subprocess import PIPE, Popen
+from threading import Thread
+
+agent_processes = [None, None]
+t = None
+q = None
+
+
+def cleanup_process():
+    global agent_processes
+    for proc in agent_processes:
+        if proc is not None:
+            proc.kill()
+
+
+def enqueue_output(out, queue):
+    for line in iter(out.readline, b""):
+        queue.put(line)
+    out.close()
+
+
+def js_agent(observation, configuration):
+    """
+    a wrapper around a js agent
+    """
+    global agent_processes, t, q
+
+    agent_process = agent_processes[observation.player]
+    ### Do not edit ###
+    if agent_process is None:
+        if "__raw_path__" in configuration:
+            cwd = os.path.dirname(configuration["__raw_path__"])
+        else:
+            cwd = os.path.dirname(__file__)
+        agent_process = Popen(["node", "main.js"], stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=cwd)
+        agent_processes[observation.player] = agent_process
+        atexit.register(cleanup_process)
+
+        # following 4 lines from https://stackoverflow.com/questions/375427/a-non-blocking-read-on-a-subprocess-pipe-in-python
+        q = Queue()
+        t = Thread(target=enqueue_output, args=(agent_process.stderr, q))
+        t.daemon = True  # thread dies with the program
+        t.start()
+    if observation.step == 0:
+        # fixes bug where updates array is shared, but the first update is agent dependent actually
+        observation["updates"][0] = f"{observation.player}"
+
+    # print observations to agent
+    agent_process.stdin.write(("\n".join(observation["updates"]) + "\n").encode())
+    agent_process.stdin.flush()
+
+    # wait for data written to stdout
+    agent1res = (agent_process.stdout.readline()).decode()
+    _end_res = (agent_process.stdout.readline()).decode()
+
+    while True:
+        try:
+            line = q.get_nowait()
+        except Empty:
+            # no standard error received, break
+            break
+        else:
+            # standard error output received, print it out
+            print(line.decode(), file=sys.stderr, end="")
+
+    outputs = agent1res.split("\n")[0].split(",")
+    actions = []
+    for cmd in outputs:
+        if cmd != "":
+            actions.append(cmd)
+    return actions

kaggle_environments/envs/lux_ai_2021/test_agents/python/lux/annotate.py

@@ -0,0 +1,20 @@
+def circle(x: int, y: int) -> str:
+    return f"dc {x} {y}"
+
+
+def x(x: int, y: int) -> str:
+    return f"dx {x} {y}"
+
+
+def line(x1: int, y1: int, x2: int, y2: int) -> str:
+    return f"dl {x1} {y1} {x2} {y2}"
+
+
+# text at cell on map
+def text(x: int, y: int, message: str, fontsize: int = 16) -> str:
+    return f"dt {x} {y} {fontsize} '{message}'"
+
+
+# text besides map
+def sidetext(message: str) -> str:
+    return f"dst '{message}'"

kaggle_environments/envs/lux_ai_2021/test_agents/python/lux/constants.py

@@ -0,0 +1,25 @@
+class Constants:
+    class INPUT_CONSTANTS:
+        RESEARCH_POINTS = "rp"
+        RESOURCES = "r"
+        UNITS = "u"
+        CITY = "c"
+        CITY_TILES = "ct"
+        ROADS = "ccd"
+        DONE = "D_DONE"
+
+    class DIRECTIONS:
+        NORTH = "n"
+        WEST = "w"
+        SOUTH = "s"
+        EAST = "e"
+        CENTER = "c"
+
+    class UNIT_TYPES:
+        WORKER = 0
+        CART = 1
+
+    class RESOURCE_TYPES:
+        WOOD = "wood"
+        URANIUM = "uranium"
+        COAL = "coal"

kaggle_environments/envs/lux_ai_2021/test_agents/python/lux/game.py

@@ -0,0 +1,86 @@
+from .constants import Constants
+from .game_map import GameMap
+from .game_objects import City, Player, Unit
+
+INPUT_CONSTANTS = Constants.INPUT_CONSTANTS
+
+
+class Game:
+    def _initialize(self, messages):
+        """
+        initialize state
+        """
+        self.id = int(messages[0])
+        self.turn = -1
+        # get some other necessary initial input
+        mapInfo = messages[1].split(" ")
+        self.map_width = int(mapInfo[0])
+        self.map_height = int(mapInfo[1])
+        self.map = GameMap(self.map_width, self.map_height)
+        self.players = [Player(0), Player(1)]
+
+    def _end_turn(self):
+        print("D_FINISH")
+
+    def _reset_player_states(self):
+        self.players[0].units = []
+        self.players[0].cities = {}
+        self.players[0].city_tile_count = 0
+        self.players[1].units = []
+        self.players[1].cities = {}
+        self.players[1].city_tile_count = 0
+
+    def _update(self, messages):
+        """
+        update state
+        """
+        self.map = GameMap(self.map_width, self.map_height)
+        self.turn += 1
+        self._reset_player_states()
+
+        for update in messages:
+            if update == "D_DONE":
+                break
+            strs = update.split(" ")
+            input_identifier = strs[0]
+            if input_identifier == INPUT_CONSTANTS.RESEARCH_POINTS:
+                team = int(strs[1])
+                self.players[team].research_points = int(strs[2])
+            elif input_identifier == INPUT_CONSTANTS.RESOURCES:
+                r_type = strs[1]
+                x = int(strs[2])
+                y = int(strs[3])
+                amt = int(float(strs[4]))
+                self.map._setResource(r_type, x, y, amt)
+            elif input_identifier == INPUT_CONSTANTS.UNITS:
+                unittype = int(strs[1])
+                team = int(strs[2])
+                unitid = strs[3]
+                x = int(strs[4])
+                y = int(strs[5])
+                cooldown = float(strs[6])
+                wood = int(strs[7])
+                coal = int(strs[8])
+                uranium = int(strs[9])
+                self.players[team].units.append(Unit(team, unittype, unitid, x, y, cooldown, wood, coal, uranium))
+            elif input_identifier == INPUT_CONSTANTS.CITY:
+                team = int(strs[1])
+                cityid = strs[2]
+                fuel = float(strs[3])
+                lightupkeep = float(strs[4])
+                self.players[team].cities[cityid] = City(team, cityid, fuel, lightupkeep)
+            elif input_identifier == INPUT_CONSTANTS.CITY_TILES:
+                team = int(strs[1])
+                cityid = strs[2]
+                x = int(strs[3])
+                y = int(strs[4])
+                cooldown = float(strs[5])
+                city = self.players[team].cities[cityid]
+                citytile = city._add_city_tile(x, y, cooldown)
+                self.map.get_cell(x, y).citytile = citytile
+                self.players[team].city_tile_count += 1
+            elif input_identifier == INPUT_CONSTANTS.ROADS:
+                x = int(strs[1])
+                y = int(strs[2])
+                road = float(strs[3])
+                self.map.get_cell(x, y).road = road

kaggle_environments/envs/lux_ai_2021/test_agents/python/lux/game_constants.json

@@ -0,0 +1,59 @@
+{
+  "UNIT_TYPES": {
+    "WORKER": 0,
+    "CART": 1
+  },
+  "RESOURCE_TYPES": {
+    "WOOD": "wood",
+    "COAL": "coal",
+    "URANIUM": "uranium"
+  },
+  "DIRECTIONS": {
+    "NORTH": "n",
+    "WEST": "w",
+    "EAST": "e",
+    "SOUTH": "s",
+    "CENTER": "c"
+  },
+  "PARAMETERS": {
+    "DAY_LENGTH": 30,
+    "NIGHT_LENGTH": 10,
+    "MAX_DAYS": 360,
+    "LIGHT_UPKEEP": {
+      "CITY": 30,
+      "WORKER": 4,
+      "CART": 10
+    },
+    "WOOD_GROWTH_RATE": 1.01,
+    "MAX_WOOD_AMOUNT": 500,
+    "CITY_BUILD_COST": 100,
+    "CITY_ADJACENCY_BONUS": 5,
+    "RESOURCE_CAPACITY": {
+      "WORKER": 100,
+      "CART": 2000
+    },
+    "WORKER_COLLECTION_RATE": {
+      "WOOD": 20,
+      "COAL": 5,
+      "URANIUM": 2
+    },
+    "RESOURCE_TO_FUEL_RATE": {
+      "WOOD": 1,
+      "COAL": 10,
+      "URANIUM": 40
+    },
+    "RESEARCH_REQUIREMENTS": {
+      "COAL": 50,
+      "URANIUM": 200
+    },
+    "CITY_ACTION_COOLDOWN": 10,
+    "UNIT_ACTION_COOLDOWN": {
+      "CART": 3,
+      "WORKER": 2
+    },
+    "MAX_ROAD": 6,
+    "MIN_ROAD": 0,
+    "CART_ROAD_DEVELOPMENT_RATE": 0.5,
+    "PILLAGE_RATE": 0.5
+  }
+}

kaggle_environments/envs/lux_ai_2021/test_agents/python/lux/game_constants.py

@@ -0,0 +1,7 @@
+import json
+from os import path
+
+dir_path = path.dirname(__file__)
+constants_path = path.abspath(path.join(dir_path, "game_constants.json"))
+with open(constants_path) as f:
+    GAME_CONSTANTS = json.load(f)

kaggle_environments/envs/lux_ai_2021/test_agents/python/lux/game_map.py

@@ -0,0 +1,106 @@
+from typing import List
+
+from .constants import Constants
+
+DIRECTIONS = Constants.DIRECTIONS
+RESOURCE_TYPES = Constants.RESOURCE_TYPES
+
+
+class Resource:
+    def __init__(self, r_type: str, amount: int):
+        self.type = r_type
+        self.amount = amount
+
+
+class Cell:
+    def __init__(self, x, y):
+        self.pos = Position(x, y)
+        self.resource: Resource = None
+        self.citytile = None
+        self.road = 0
+
+    def has_resource(self):
+        return self.resource is not None and self.resource.amount > 0
+
+
+class GameMap:
+    def __init__(self, width, height):
+        self.height = height
+        self.width = width
+        self.map: List[List[Cell]] = [None] * height
+        for y in range(0, self.height):
+            self.map[y] = [None] * width
+            for x in range(0, self.width):
+                self.map[y][x] = Cell(x, y)
+
+    def get_cell_by_pos(self, pos) -> Cell:
+        return self.map[pos.y][pos.x]
+
+    def get_cell(self, x, y) -> Cell:
+        return self.map[y][x]
+
+    def _setResource(self, r_type, x, y, amount):
+        """
+        do not use this function, this is for internal tracking of state
+        """
+        cell = self.get_cell(x, y)
+        cell.resource = Resource(r_type, amount)
+
+
+class Position:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def __sub__(self, pos) -> int:
+        return abs(pos.x - self.x) + abs(pos.y - self.y)
+
+    def distance_to(self, pos):
+        """
+        Returns Manhattan (L1/grid) distance to pos
+        """
+        return self - pos
+
+    def is_adjacent(self, pos):
+        return (self - pos) <= 1
+
+    def __eq__(self, pos) -> bool:
+        return self.x == pos.x and self.y == pos.y
+
+    def equals(self, pos):
+        return self == pos
+
+    def translate(self, direction, units) -> "Position":
+        if direction == DIRECTIONS.NORTH:
+            return Position(self.x, self.y - units)
+        elif direction == DIRECTIONS.EAST:
+            return Position(self.x + units, self.y)
+        elif direction == DIRECTIONS.SOUTH:
+            return Position(self.x, self.y + units)
+        elif direction == DIRECTIONS.WEST:
+            return Position(self.x - units, self.y)
+        elif direction == DIRECTIONS.CENTER:
+            return Position(self.x, self.y)
+
+    def direction_to(self, target_pos: "Position") -> DIRECTIONS:
+        """
+        Return closest position to target_pos from this position
+        """
+        check_dirs = [
+            DIRECTIONS.NORTH,
+            DIRECTIONS.EAST,
+            DIRECTIONS.SOUTH,
+            DIRECTIONS.WEST,
+        ]
+        closest_dist = self.distance_to(target_pos)
+        closest_dir = DIRECTIONS.CENTER
+        for direction in check_dirs:
+            newpos = self.translate(direction, 1)
+            dist = target_pos.distance_to(newpos)
+            if dist < closest_dist:
+                closest_dir = direction
+                closest_dist = dist
+        return closest_dir
+
+    def __str__(self) -> str:
+        return f"({self.x}, {self.y})"