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

kaggle_environments/envs/lux_ai_2021/lux_ai_2021.py

@@ -0,0 +1,231 @@
+import atexit
+import json
+import math
+import random
+import sys
+from os import path
+from queue import Empty, Queue
+from subprocess import PIPE, Popen
+from threading import Thread
+
+from .agents import agents as all_agents
+from .test_agents.python.lux.game import Game
+
+t = None
+q = None
+dimension_process = None
+game_state = Game()
+prev_step = 0
+
+
+def cleanup_dimensions():
+    global dimension_process
+    if dimension_process is not None:
+        dimension_process.kill()
+
+
+def enqueue_output(out, queue):
+    for line in iter(out.readline, b""):
+        queue.put(line)
+    out.close()
+
+
+def interpreter(state, env):
+    global dimension_process, game_state, t, q, prev_step
+    player1 = state[0]
+    player2 = state[1]
+
+    ### 1.1: Initialize dimensions in the background within the orchestrator if we haven't already ###
+    if dimension_process is None:
+        # dimension_process = Popen(["ts-node", "-P", path.abspath(path.join(dir_path, "dimensions/tsconfig.json")), path.abspath(path.join(dir_path, "dimensions/run.ts"))], stdin=PIPE, stdout=PIPE)
+        try:
+            dimension_process = Popen(
+                ["node", path.abspath(path.join(dir_path, "dimensions/main.js"))], stdin=PIPE, stdout=PIPE, stderr=PIPE
+            )
+        except FileNotFoundError:
+            import warnings
+
+            warnings.warn("Node not installed")
+            return state
+
+        # 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=(dimension_process.stdout, q))
+        t.daemon = True  # thread dies with the program
+        t.start()
+        atexit.register(cleanup_dimensions)
+
+    # filter out actions such as debug annotations so they aren't saved
+    filter_actions(state, env)
+
+    ### 1.2: Initialize a blank state game if new episode is starting ###
+    if env.done:
+        # TODO: allow resetting to a specific state
+        # print("Initialize game", "steps", len(env.steps), "prev_step", prev_step)
+        # last_state = None
+        # if prev_step >= len(env.steps):
+        #     last_state = env.steps[-1]
+        # prev_step = len(env.steps)
+        # print("prev_step now", prev_step)
+        if "seed" in env.configuration:
+            seed = env.configuration["seed"]
+        else:
+            seed = math.floor(random.random() * 1e9)
+            env.configuration["seed"] = seed
+        if "loglevel" in env.configuration:
+            loglevel = env.configuration["loglevel"]
+        else:
+            loglevel = 0  # warnings, 1: errors, 0: none
+            env.configuration["loglevel"] = loglevel
+        if "annotations" in env.configuration:
+            annotations = env.configuration["annotations"]
+        else:
+            annotations = False  # warnings, 1: errors, 0: none
+            env.configuration["annotations"] = annotations
+
+        if "width" in env.configuration:
+            width = env.configuration["width"]
+        else:
+            width = -1  # -1 for randomly selected
+            env.configuration["width"] = width
+        if "height" in env.configuration:
+            height = env.configuration["height"]
+        else:
+            height = -1  # -1 for randomly selected
+            env.configuration["height"] = height
+
+        initiate = {
+            "type": "start",
+            "agent_names": [],  # unsure if this is provided?
+            "config": env.configuration,
+        }
+        # if last_state is not None:
+        #     initiate["state"] = last_state
+        dimension_process.stdin.write((json.dumps(initiate) + "\n").encode())
+        dimension_process.stdin.flush()
+
+        agent1res = get_message(dimension_process)
+        agent2res = get_message(dimension_process)
+        match_obs_meta = get_message(dimension_process)
+
+        player1.observation.player = 0
+        player2.observation.player = 1
+        player1.observation.updates = agent1res
+
+        # player2.observation.updates = agent2res # duplicated and not added
+        player1.observation.globalCityIDCount = match_obs_meta["globalCityIDCount"]
+        player1.observation.globalUnitIDCount = match_obs_meta["globalUnitIDCount"]
+        player1.observation.width = match_obs_meta["width"]
+        player1.observation.height = match_obs_meta["height"]
+
+        game_state = Game()
+        game_state._initialize(agent1res)
+
+        return state
+    # print("prev_step", prev_step, "stored steps", len(env.steps))
+    # prev_step += 1
+
+    ### 2. : Pass in actions (json representation along with id of who made that action), agent information (id, status) to dimensions via stdin
+    dimension_process.stdin.write((json.dumps(state) + "\n").encode())
+    dimension_process.stdin.flush()
+
+    ### 3.1 : Receive and parse the observations returned by dimensions via stdout
+    agent1res = json.loads(dimension_process.stderr.readline())
+    agent2res = json.loads(dimension_process.stderr.readline())
+    game_state._update(agent1res)
+
+    # receive meta info such as global ID and map sizes for purposes of being able to start from specific state
+    match_obs_meta = json.loads(dimension_process.stderr.readline())
+    match_status = json.loads(dimension_process.stderr.readline())
+
+    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="")
+
+    ### 3.2 : Send observations to each agent through here. Like dimensions, first observation can include initialization stuff, then we do the looping
+
+    player1.observation.updates = agent1res
+
+    player1.observation.globalCityIDCount = match_obs_meta["globalCityIDCount"]
+    player1.observation.globalUnitIDCount = match_obs_meta["globalUnitIDCount"]
+    player1.observation.width = match_obs_meta["width"]
+    player1.observation.height = match_obs_meta["height"]
+    # player2.observation.updates = agent2res # duplicated and not added
+
+    player1.observation.player = 0
+    player2.observation.player = 1
+
+    ### 3.3 : handle rewards
+    # reward here is defined as the sum of number of city tiles
+    player1.reward = compute_reward(game_state.players[0])
+    player2.reward = compute_reward(game_state.players[1])
+    player1.observation.reward = int(player1.reward)
+    player2.observation.reward = int(player2.reward)
+
+    ### 3.4 Handle finished match status
+    if match_status["status"] == "finished":
+        if player1.status == "ACTIVE":
+            player1.status = "DONE"
+        if player2.status == "ACTIVE":
+            player2.status = "DONE"
+    return state
+
+
+def get_message(dimension_process):
+    raw = dimension_process.stderr.readline()
+    try:
+        res = json.loads(raw)
+        return res
+    except Exception:
+        print("Engine Exception")
+        err_stack = dimension_process.stderr.readlines(100)
+        # err_stack = [raw, *err_stack]
+        # print(err_stack)
+        for m in err_stack:
+            if len(m) < 1000:
+                print(m.decode(), file=sys.stderr)
+            else:
+                print("...", file=sys.stderr)
+
+
+def filter_actions(state, env):
+    enable_annotations = env.configuration["annotations"]
+    if not enable_annotations:
+        for team in range(len(state)):
+            filtered = []
+            if state[team] is not None and state[team].action is not None:
+                for l in state[team].action:
+                    if len(l) > 0 and l[0] != "d":
+                        filtered.append(l)
+                state[team].action = filtered
+
+
+def compute_reward(player):
+    ct_count = sum([len(v.citytiles) for k, v in player.cities.items()])
+    unit_count = len(game_state.players[player.team].units)
+    # max board size is 32 x 32 => 1024 max city tiles and units, so this should keep it strictly so we break by city tiles then unit count
+    return ct_count * 10000 + unit_count
+
+
+def renderer(state, env):
+    raise NotImplementedError("To render the replay, please set the render mode to json or html")
+
+
+dir_path = path.dirname(__file__)
+json_path = path.abspath(path.join(dir_path, "lux_ai_2021.json"))
+with open(json_path) as json_file:
+    specification = json.load(json_file)
+
+
+def html_renderer():
+    html_path = path.abspath(path.join(dir_path, "index.html"))
+    return ("html_path", html_path)
+
+
+agents = all_agents

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

@@ -0,0 +1,6 @@
+/**
+ * All game constants
+ */
+const GAME_CONSTANTS = require('./game_constants.json');
+
+module.exports = GAME_CONSTANTS;

kaggle_environments/envs/lux_ai_2021/test_agents/js_simple/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/js_simple/lux/game_objects.js

@@ -0,0 +1,145 @@
+/**
+ * All game objects for access by user
+ */
+const {
+  Position
+} = require("./map");
+const GAME_CONSTANTS = require("./game_constants");
+
+/**
+ * holds all data related to a player
+ */
+class Player {
+  constructor(teamid) {
+    this.team = teamid;
+    this.researchPoints = 0;
+    // map unit id to the unit
+    this.units = [];
+    this.cities = new Map();
+    this.cityTileCount = 0;
+  }
+  researchedCoal() {
+    return this.researchPoints >= GAME_CONSTANTS.PARAMETERS.RESEARCH_REQUIREMENTS.COAL;
+  }
+  researchedUranium() {
+    return this.researchPoints >= GAME_CONSTANTS.PARAMETERS.RESEARCH_REQUIREMENTS.URANIUM;
+  }
+}
+
+// all data related to a city
+class City {
+  constructor(teamid, cityid, fuel, lightUpkeep) {
+    this.cityid = cityid;
+    this.team = teamid;
+    this.fuel = fuel;
+    this.citytiles = [];
+    this.lightUpkeep = lightUpkeep;
+  }
+  addCityTile(x, y, cooldown) {
+    const ct = new CityTile(this.team, this.cityid, x, y, cooldown)
+    this.citytiles.push(ct);
+    return ct;
+  }
+  getLightUpkeep() {
+    return this.lightUpkeep;
+  }
+}
+
+/** CityTile and Unit are both actionable and can return action strings to send to engine  */
+class CityTile {
+  constructor(teamid, cityid, x, y, cooldown) {
+    this.cityid = cityid;
+    this.team = teamid;
+    this.pos = new Position(x, y);
+    this.cooldown = cooldown;
+  }
+  /** Whether or not this unit can research or build */
+  canAct() {
+    return this.cooldown < 1;
+  }
+  /** returns command to ask this tile to research this turn */
+  research() {
+    return `r ${this.pos.x} ${this.pos.y}`;
+  }
+  /** returns command to ask this tile to build a worker this turn */
+  buildWorker() {
+    return `bw ${this.pos.x} ${this.pos.y}`;
+  }
+  /** returns command to ask this tile to build a cart this turn */
+  buildCart() {
+    return `bc ${this.pos.x} ${this.pos.y}`;
+  }
+}
+
+class Unit {
+  constructor(teamid, type, unitid, x, y, cooldown, wood, coal, uranium) {
+    this.pos = new Position(x, y);
+    this.team = teamid;
+    this.id = unitid;
+    this.type = type;
+    this.cooldown = cooldown;
+    this.cargo = {
+      wood,
+      coal,
+      uranium
+    }
+  }
+  isWorker() {
+    return this.type === GAME_CONSTANTS.UNIT_TYPES.WORKER;
+  }
+
+  isCart() {
+    return this.type === GAME_CONSTANTS.UNIT_TYPES.CART;
+  }
+
+  getCargoSpaceLeft() {
+    const spaceused = this.cargo.wood + this.cargo.coal + this.cargo.uranium;
+    if (this.type === GAME_CONSTANTS.UNIT_TYPES.WORKER) {
+      return GAME_CONSTANTS.PARAMETERS.RESOURCE_CAPACITY.WORKER - spaceused;
+    } else {
+      return GAME_CONSTANTS.PARAMETERS.RESOURCE_CAPACITY.CART - spaceused;
+    }
+  }
+
+  /** whether or not the unit can build where it is right now */
+  canBuild(gameMap) {
+    let cell = gameMap.getCellByPos(this.pos);
+    if (!cell.hasResource() && this.canAct() && (this.cargo.wood + this.cargo.coal + this.cargo.uranium) >= GAME_CONSTANTS.PARAMETERS.CITY_BUILD_COST) {
+      return true;
+    }
+    return false;
+  }
+
+  /** whether or not the unit can act or not. This does not check for potential collisions into other units or enemy cities */
+  canAct() {
+    return this.cooldown < 1;
+  }
+
+  /** return the command to move unit in the given direction */
+  move(dir) {
+    return `m ${this.id} ${dir}`;
+  }
+
+  /** return the command to transfer a resource from a source unit to a destination unit as specified by their ids or the units themselves */
+  transfer(destUnit, resourceType, amount) {
+    let destID = typeof destUnit === "string" ? destUnit : destUnit.id;
+    return `t ${this.id} ${destID} ${resourceType} ${amount}`;
+  }
+
+  /** return the command to build a city right under the worker */
+  buildCity() {
+    return `bcity ${this.id}`;
+  }
+
+  /** return the command to pillage whatever is underneath the worker */
+  pillage() {
+    return `p ${this.id}`;
+  }
+}
+
+module.exports = {
+  Player,
+  City,
+  Unit,
+  CityTile,
+}

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

@@ -0,0 +1,14 @@
+/** all constants related to any input from match engine */
+const INPUT_CONSTANTS = {
+  DONE: 'D_DONE',
+  RESEARCH_POINTS: 'rp',
+  RESOURCES: 'r',
+  UNITS: 'u',
+  CITY: 'c',
+  CITY_TILES: 'ct',
+  ROADS: 'ccd',
+}
+
+module.exports = {
+  INPUT_CONSTANTS,
+}

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

@@ -0,0 +1,209 @@
+const fs = require('fs');
+const readline = require('readline');
+
+// Create parser and use ',' as the delimiter between commands being sent by the `Match` and `MatchEngine`
+const Parser = require('./parser');
+const {
+  GameMap
+} = require('./map');
+const {
+  INPUT_CONSTANTS
+} = require('./io');
+const {
+  Player,
+  City,
+  Unit,
+} = require('./game_objects');
+const GAME_CONSTANTS = require('./game_constants');
+const parse = new Parser(' ');
+
+/**
+ * Agent for sequential `Designs`
+ */
+class Agent {
+  _setup() {
+
+    // Prepare to read input
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: null,
+    });
+
+    let buffer = [];
+    let currentResolve;
+    const makePromise = function () {
+      return new Promise((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
+    let currentPromise = makePromise();
+
+    // with await, we pause process until there is input
+    const 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(parse(buffer.shift()));
+      });
+    };
+    this.getLine = getLine;
+  }
+
+  /**
+   * Constructor for a new agent
+   * User should edit this according to the `Design` this agent will compete under
+   */
+  constructor() {
+    this._setup(); // DO NOT REMOVE
+  }
+
+  /**
+   * Initialize Agent for the `Match`
+   * User should edit this according to their `Design`
+   */
+  async initialize() {
+
+    // get agent ID
+    const id = (await this.getLine()).nextInt();
+    // get some other necessary initial input
+    let mapInfo = (await this.getLine());
+    let width = mapInfo.nextInt();
+    let height = mapInfo.nextInt();
+    const map = new GameMap(width, height);
+    const players = [new Player(0), new Player(1)];
+
+    this.gameState = {
+      id,
+      map,
+      players,
+      turn: -1,
+    };
+  }
+  /**
+   * Updates agent's own known state of `Match`
+   * User should edit this according to their `Design`.
+   */
+  async update() {
+    this.gameState.turn++;
+    // wait for the engine to send any updates
+    await this.retrieveUpdates();
+  }
+
+  resetPlayerStates() {
+    let players = this.gameState.players;
+    players[0].units = [];
+    players[0].cities = new Map();
+    players[0].cityTileCount = 0;
+    players[1].units = [];
+    players[1].cities = new Map();
+    players[1].cityTileCount = 0;
+  }
+  async retrieveUpdates() {
+    this.resetPlayerStates();
+    // TODO: this can be optimized. we only reset because some resources get removed
+    this.gameState.map = new GameMap(this.gameState.map.width, this.gameState.map.height);
+    while (true) {
+      let update = (await this.getLine());
+      if (update.str === INPUT_CONSTANTS.DONE) {
+        break;
+      }
+      const inputIdentifier = update.nextStr();
+      switch (inputIdentifier) {
+        case INPUT_CONSTANTS.RESEARCH_POINTS: {
+          const team = update.nextInt();
+          this.gameState.players[team].researchPoints = update.nextInt();
+          break;
+        }
+        case INPUT_CONSTANTS.RESOURCES: {
+          const type = update.nextStr();
+          const x = update.nextInt();
+          const y = update.nextInt();
+          const amt = update.nextInt();
+          this.gameState.map._setResource(type, x, y, amt);
+          break;
+        }
+        case INPUT_CONSTANTS.UNITS: {
+          const unittype = update.nextInt();
+          const team = update.nextInt();
+          const unitid = update.nextStr();
+          const x = update.nextInt();
+          const y = update.nextInt();
+          const cooldown = update.nextFloat();
+          const wood = update.nextInt();
+          const coal = update.nextInt();
+          const uranium = update.nextInt();
+          this.gameState.players[team].units.push(new Unit(team, unittype, unitid, x, y, cooldown, wood, coal, uranium));
+          break;
+        }
+        case INPUT_CONSTANTS.CITY: {
+          const team = update.nextInt();
+          const cityid = update.nextStr();
+          const fuel = update.nextFloat();
+          const lightUpkeep = update.nextFloat();
+          this.gameState.players[team].cities.set(cityid, new City(team, cityid, fuel, lightUpkeep));
+          break;
+        }
+        case INPUT_CONSTANTS.CITY_TILES: {
+          const team = update.nextInt();
+          const cityid = update.nextStr();
+          const x = update.nextInt();
+          const y = update.nextInt();
+          const cooldown = update.nextFloat();
+          const city = this.gameState.players[team].cities.get(cityid);
+          const citytile = city.addCityTile(x, y, cooldown);
+          this.gameState.map.getCell(x, y).citytile = citytile;
+          this.gameState.players[team].cityTileCount += 1;
+          break;
+        }
+        case INPUT_CONSTANTS.ROADS: {
+          const x = update.nextInt();
+          const y = update.nextInt();
+          const road = update.nextFloat();
+          this.gameState.map.getCell(x, y).road = road;
+          break;
+        }
+      }
+    }
+  }
+
+  /**
+   * End a turn
+   */
+  endTurn() {
+    console.log('D_FINISH');
+  }
+}
+
+const annotate = {
+  circle: (x, y) => {
+    return `dc ${x} ${y}`
+  },
+  x: (x, y) => {
+    return `dx ${x} ${y}`
+  },
+  line: (x1, y1, x2, y2) => {
+    return `dl ${x1} ${y1} ${x2} ${y2}`
+  },
+  text: (x1, y1, message, fontsize = 16) => {
+    return `dt ${x1} ${y1} ${fontsize} '${message}'`
+  },
+  sidetext: (message) => {
+    return `dst '${message}'`
+  }
+}
+
+module.exports = {
+  Agent,
+  annotate
+};