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

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

@@ -0,0 +1,154 @@
+from typing import Dict
+
+from .constants import Constants
+from .game_constants import GAME_CONSTANTS
+from .game_map import Position
+
+UNIT_TYPES = Constants.UNIT_TYPES
+
+
+class Player:
+    def __init__(self, team):
+        self.team = team
+        self.research_points = 0
+        self.units: list[Unit] = []
+        self.cities: Dict[str, City] = {}
+        self.city_tile_count = 0
+
+    def researched_coal(self) -> bool:
+        return self.research_points >= GAME_CONSTANTS["PARAMETERS"]["RESEARCH_REQUIREMENTS"]["COAL"]
+
+    def researched_uranium(self) -> bool:
+        return self.research_points >= GAME_CONSTANTS["PARAMETERS"]["RESEARCH_REQUIREMENTS"]["URANIUM"]
+
+
+class City:
+    def __init__(self, teamid, cityid, fuel, light_upkeep):
+        self.cityid = cityid
+        self.team = teamid
+        self.fuel = fuel
+        self.citytiles: list[CityTile] = []
+        self.light_upkeep = light_upkeep
+
+    def _add_city_tile(self, x, y, cooldown):
+        ct = CityTile(self.team, self.cityid, x, y, cooldown)
+        self.citytiles.append(ct)
+        return ct
+
+    def get_light_upkeep(self):
+        return self.light_upkeep
+
+
+class CityTile:
+    def __init__(self, teamid, cityid, x, y, cooldown):
+        self.cityid = cityid
+        self.team = teamid
+        self.pos = Position(x, y)
+        self.cooldown = cooldown
+
+    def can_act(self) -> bool:
+        """
+        Whether or not this unit can research or build
+        """
+        return self.cooldown < 1
+
+    def research(self) -> str:
+        """
+        returns command to ask this tile to research this turn
+        """
+        return "r {} {}".format(self.pos.x, self.pos.y)
+
+    def build_worker(self) -> str:
+        """
+        returns command to ask this tile to build a worker this turn
+        """
+        return "bw {} {}".format(self.pos.x, self.pos.y)
+
+    def build_cart(self) -> str:
+        """
+        returns command to ask this tile to build a cart this turn
+        """
+        return "bc {} {}".format(self.pos.x, self.pos.y)
+
+
+class Cargo:
+    def __init__(self):
+        self.wood = 0
+        self.coal = 0
+        self.uranium = 0
+
+    def __str__(self) -> str:
+        return f"Cargo | Wood: {self.wood}, Coal: {self.coal}, Uranium: {self.uranium}"
+
+
+class Unit:
+    def __init__(self, teamid, u_type, unitid, x, y, cooldown, wood, coal, uranium):
+        self.pos = Position(x, y)
+        self.team = teamid
+        self.id = unitid
+        self.type = u_type
+        self.cooldown = cooldown
+        self.cargo = Cargo()
+        self.cargo.wood = wood
+        self.cargo.coal = coal
+        self.cargo.uranium = uranium
+
+    def is_worker(self) -> bool:
+        return self.type == UNIT_TYPES.WORKER
+
+    def is_cart(self) -> bool:
+        return self.type == UNIT_TYPES.CART
+
+    def get_cargo_space_left(self):
+        """
+        get cargo space left in this unit
+        """
+        spaceused = self.cargo.wood + self.cargo.coal + self.cargo.uranium
+        if self.type == UNIT_TYPES.WORKER:
+            return GAME_CONSTANTS["PARAMETERS"]["RESOURCE_CAPACITY"]["WORKER"] - spaceused
+        else:
+            return GAME_CONSTANTS["PARAMETERS"]["RESOURCE_CAPACITY"]["CART"] - spaceused
+
+    def can_build(self, game_map) -> bool:
+        """
+        whether or not the unit can build where it is right now
+        """
+        cell = game_map.get_cell_by_pos(self.pos)
+        if (
+            not cell.has_resource()
+            and self.can_act()
+            and (self.cargo.wood + self.cargo.coal + self.cargo.uranium)
+            >= GAME_CONSTANTS["PARAMETERS"]["CITY_BUILD_COST"]
+        ):
+            return True
+        return False
+
+    def can_act(self) -> bool:
+        """
+        whether or not the unit can move or not. This does not check for potential collisions into other units or enemy cities
+        """
+        return self.cooldown < 1
+
+    def move(self, dir) -> str:
+        """
+        return the command to move unit in the given direction
+        """
+        return "m {} {}".format(self.id, dir)
+
+    def transfer(self, dest_id, resourceType, amount) -> str:
+        """
+        return the command to transfer a resource from a source unit to a destination unit as specified by their ids
+        """
+        return "t {} {} {} {}".format(self.id, dest_id, resourceType, amount)
+
+    def build_city(self) -> str:
+        """
+        return the command to build a city right under the worker
+        """
+        return "bcity {}".format(self.id)
+
+    def pillage(self) -> str:
+        """
+        return the command to pillage whatever is underneath the worker
+        """
+        return "p {}".format(self.id)

kaggle_environments/envs/lux_ai_2021/test_agents/python/random_agent.py

@@ -0,0 +1,38 @@
+import random
+
+if __package__ == "":
+    # for kaggle-environments
+    from lux.constants import Constants
+    from lux.game import Game
+else:
+    # for CLI tool
+    from .lux.constants import Constants
+    from .lux.game import Game
+DIRECTIONS = Constants.DIRECTIONS
+game_state = None
+
+
+def random_agent(observation, configuration):
+    """
+    a blank, completely empty agent, usually incapable of surviving past the first night
+    """
+    global game_state
+
+    ### Do not edit ###
+    if observation["step"] == 0:
+        game_state = Game()
+        game_state._initialize(observation["updates"])
+        game_state._update(observation["updates"][2:])
+    else:
+        game_state._update(observation["updates"])
+
+    actions = []
+
+    ### AI Code goes down here! ###
+    player = game_state.players[observation.player]
+    for unit in player.units:
+        dirs = [DIRECTIONS.NORTH, DIRECTIONS.WEST, DIRECTIONS.EAST, DIRECTIONS.SOUTH]
+        action = unit.move(random.choice(dirs))
+        actions.append(action)
+
+    return actions

kaggle_environments/envs/lux_ai_2021/test_agents/python/simple_agent.py

@@ -0,0 +1,82 @@
+import math
+
+if __package__ == "":
+    # for kaggle-environments
+    from lux.constants import Constants
+    from lux.game import Game
+    from lux.game_map import Cell
+else:
+    # for CLI tool
+    from .lux.constants import Constants
+    from .lux.game import Game
+    from .lux.game_map import Cell
+
+DIRECTIONS = Constants.DIRECTIONS
+game_state = None
+
+
+def agent(observation, configuration):
+    global game_state
+
+    ### Do not edit ###
+    if observation["step"] == 0:
+        game_state = Game()
+        game_state._initialize(observation["updates"])
+        game_state._update(observation["updates"][2:])
+    else:
+        game_state._update(observation["updates"])
+
+    actions = []
+
+    ### AI Code goes down here! ###
+    player = game_state.players[observation.player]
+    opponent = game_state.players[(observation.player + 1) % 2]
+    width, height = game_state.map.width, game_state.map.height
+
+    resource_tiles: list[Cell] = []
+    for y in range(height):
+        for x in range(width):
+            cell = game_state.map.get_cell(x, y)
+            if cell.has_resource():
+                resource_tiles.append(cell)
+
+    # we iterate over all our units and do something with them
+    for unit in player.units:
+        if unit.is_worker() and unit.can_act():
+            closest_dist = math.inf
+            closest_resource_tile = None
+            if unit.get_cargo_space_left() > 0:
+                # if the unit is a worker and we have space in cargo, lets find the nearest resource tile and try to mine it
+                for resource_tile in resource_tiles:
+                    if resource_tile.resource.type == Constants.RESOURCE_TYPES.COAL and not player.researched_coal():
+                        continue
+                    if (
+                        resource_tile.resource.type == Constants.RESOURCE_TYPES.URANIUM
+                        and not player.researched_uranium()
+                    ):
+                        continue
+                    dist = resource_tile.pos.distance_to(unit.pos)
+                    if dist < closest_dist:
+                        closest_dist = dist
+                        closest_resource_tile = resource_tile
+                if closest_resource_tile is not None:
+                    actions.append(unit.move(unit.pos.direction_to(closest_resource_tile.pos)))
+            else:
+                # if unit is a worker and there is no cargo space left, and we have cities, lets return to them
+                if len(player.cities) > 0:
+                    closest_dist = math.inf
+                    closest_city_tile = None
+                    for k, city in player.cities.items():
+                        for city_tile in city.citytiles:
+                            dist = city_tile.pos.distance_to(unit.pos)
+                            if dist < closest_dist:
+                                closest_dist = dist
+                                closest_city_tile = city_tile
+                    if closest_city_tile is not None:
+                        move_dir = unit.pos.direction_to(closest_city_tile.pos)
+                        actions.append(unit.move(move_dir))
+
+    # you can add debug annotations using the functions in the annotate object
+    # actions.append(annotate.circle(0, 0))
+
+    return actions

kaggle_environments/envs/lux_ai_2021/test_lux.py

@@ -0,0 +1,19 @@
+from kaggle_environments import make
+
+from .agents import js_simple_agent, random_agent, simple_agent
+
+
+def test_lux_completes():
+    env = make("lux_ai_2021", configuration={})
+    env.run([random_agent, simple_agent])
+    json = env.toJSON()
+    assert json["name"] == "lux_ai_2021"
+    assert json["statuses"] == ["DONE", "DONE"]
+
+
+def test_js_agents():
+    env = make("lux_ai_2021", configuration={})
+    env.run([simple_agent, js_simple_agent])
+    json = env.toJSON()
+    assert json["name"] == "lux_ai_2021"
+    assert json["statuses"] == ["DONE", "DONE"]

kaggle_environments/envs/lux_ai_2021/testing.md

@@ -0,0 +1,23 @@
+Unfortunately at this moment, there isn't a progammatic way to test if the Kaggle Engine is the exact same as the engine competitors use when local testing. This is part of a TODO to make kaggle replays match the local replays players generate when they develop locally using https://github.com/Lux-AI-Challenge/Lux-Design-2021
+
+The following steps work for now:
+
+First download the simple kit from https://github.com/Lux-AI-Challenge/Lux-Design-2021/tree/master/kits/python (or another language) or use your own bot
+
+First run a game in Kaggle like so:
+
+```
+kaggle-environments run --environment lux_ai_2021 --agents path/to/bot/main.py path/to/bot/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+
+Then upload the out.json to https://2021vis.lux-ai.org/ and go to the final turn.
+
+Then install the local engine `npm i -g install @lux-ai/2021-challenge` if you haven't done so already (you can remove `-g` and do `npx lux-ai-2021` as opposed to `lux-ai-2021`)
+
+Then run
+
+```
+lux-ai-2021 path/to/bot/main.py path/to/bot/main.py --out=replay.json
+```
+
+upload `replay.json` to the replay viewer again in a new tab and compare the final state with the other kaggle produced match. If the statistics and layout of units on the map match, then the engine is working correctly. (Given the complexity of the game and that `lux-ai-2021` generates action based replays, should a single thing be wrong, the differences in the final turn would be fairly massive so this is generally a sufficient test)

kaggle_environments/envs/lux_ai_2021/todo.md.og

@@ -0,0 +1,18 @@
+# TODOs
+
+
+[x] Setup Visualizer
+
+[x] Keep dimensions engine results consistent with kaggle-env integated version
+
+[ ] Verify rewards work correctly
+
+[ ] display correct agent names
+
+[ ] default turn debug mode off
+
+[ ] add tests for more bots
+
+[ ] allow user to pass in custom configurations
+
+[ ] allow user to specify debug mode level for the dimensions engine

kaggle_environments/envs/lux_ai_s3/README.md

@@ -0,0 +1,21 @@
+# Lux AI Challenge Season 3
+
+Welcome to the Kaggle Environments wrapped around the Lux AI Challenge Season 3! For more information or if you have an issues or want to make contributes, check out the main repository at https://github.com/Lux-AI-Challenge/Lux-Design-S3
+
+## Test scripts
+
+```
+kaggle-environments run --environment lux_ai_s3 --agents path/to/bot/main.py path/to/bot/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+
+```
+kaggle-environments run --environment lux_ai_s3 --agents ../LuxAI/Lux-Design-S3/kits/python/main.py ../LuxAI/Lux-Design-S3/kits/python/main.py --render '{"mode": "json"}' --out out.json --debug=True
+```
+<!-- 
+## Packaging external packages locally
+
+git clone open_simplex and petting zoo directly and move them into here -->
+
+## Visualizer
+
+Ensure that the script module is at the bottom of <body> tag.

kaggle_environments/envs/lux_ai_s3/agents.py

@@ -0,0 +1,5 @@
+from .test_agents.python.main import agent_fn as random_agent
+
+all_agents = {
+    "random_agent": random_agent,
+}

kaggle_environments/envs/lux_ai_s3/index.html

@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="https://s3vis.lux-ai.org/eye.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+
+    <title>Lux Eye S3</title>
+
+    <!-- Start Single Page Apps for GitHub Pages -->
+    <script type="text/javascript">
+      // Single Page Apps for GitHub Pages
+      // MIT License
+      // https://github.com/rafgraph/spa-github-pages
+      // This script checks to see if a redirect is present in the query string,
+      // converts it back into the correct url and adds it to the
+      // browser's history using window.history.replaceState(...),
+      // which won't cause the browser to attempt to load the new url.
+      // When the single page app is loaded further down in this file,
+      // the correct url will be waiting in the browser's history for
+      // the single page app to route accordingly.
+      (function (l) {
+        if (l.search[1] === '/') {
+          const decoded = l.search
+            .slice(1)
+            .split('&')
+            .map(function (s) {
+              return s.replace(/~and~/g, '&');
+            })
+            .join('?');
+          window.history.replaceState(null, null, l.pathname.slice(0, -1) + decoded + l.hash);
+        }
+      })(window.location);
+    </script>
+    <!-- End Single Page Apps for GitHub Pages -->
+    <script type="module" crossorigin src="https://s3vis.lux-ai.org/index.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+    
+  </body>
+</html>

kaggle_environments/envs/lux_ai_s3/lux_ai_s3.json

@@ -0,0 +1,47 @@
+{
+  "name": "lux_ai_s3",
+  "title": "Lux AI Challenge Season 3",
+  "description": "A Novel AI Programming Challenge about Lux",
+  "version": "0.0.1",
+  "agents": [2],
+  "configuration": {
+    "episodeSteps": 506,
+    "seed": {
+      "description": "Seed to use for episodes",
+      "type": "integer"
+    },
+    "actTimeout": 3,
+    "runTimeout": 1600,
+    "env_cfg": {
+      "description": "Environment configuration. Not to be filled out by user as it is randomly generated.",
+      "type": "object"
+    }
+  },
+  "reward": {
+    "description": "Reward of the agent. Equal to number of games won.",
+    "type": "integer",
+    "default": 0
+  },
+  "observation": {
+    "remainingOverageTime": 60,
+    "reward": {
+      "description": "Current reward of the agent. Equal to amount of lichen grown.",
+      "type": "integer",
+      "default": 0
+    },
+    "obs": {
+      "description": "String containing the observations",
+      "type": "string",
+      "shared": false
+    },
+    "player": {
+      "description": "Current player's index / team id",
+      "type": "string",
+      "defaults": "player_0"
+    }
+  },
+  "action": {
+    "description": "Actions",
+    "type": "object"
+  }
+}

kaggle_environments/envs/lux_ai_s3/lux_ai_s3.py

@@ -0,0 +1,178 @@
+import json
+import math
+import random
+from os import path
+from os import path as osp
+from sys import path as syspath
+
+from .agents import all_agents
+
+# next two lines enables importing local packages e.g. luxai_s3
+__dir__ = osp.dirname(__file__)
+syspath.append(__dir__)
+import numpy as np
+
+
+def to_json(state):
+    if isinstance(state, np.ndarray):
+        return state.tolist()
+    elif isinstance(state, np.int64):
+        return state.tolist()
+    elif isinstance(state, list):
+        return [to_json(s) for s in state]
+    elif isinstance(state, dict):
+        out = {}
+        for k in state:
+            out[k] = to_json(state[k])
+        return out
+    else:
+        return state
+
+
+prev_step = 0
+luxenv = None
+prev_obs = None
+state_obs = None
+default_env_cfg = None
+
+
+def enqueue_output(out, queue):
+    for line in iter(out.readline, b""):
+        queue.put(line)
+    out.close()
+
+
+def interpreter(state, env):
+    try:
+        from luxai_s3.wrappers import LuxAIS3GymEnv, RecordEpisode
+
+        global luxenv, prev_obs, state_obs, default_env_cfg
+        player_0 = state[0]
+        player_1 = state[1]
+        # filter out actions such as debug annotations so they aren't saved
+        # filter_actions(state, env)
+
+        if env.done:
+            if "seed" in env.configuration:
+                seed = int(env.configuration["seed"])
+            else:
+                seed = math.floor(random.random() * 1e9)
+                env.configuration["seed"] = seed
+
+            luxenv = LuxAIS3GymEnv(numpy_output=True)
+            luxenv = RecordEpisode(luxenv, save_on_close=False, save_on_reset=False)
+            obs, info = luxenv.reset(seed=seed)
+
+            env_cfg_json = info["params"]
+
+            env.configuration.env_cfg = env_cfg_json
+
+            player_0.observation.player = "player_0"
+            player_1.observation.player = "player_1"
+            player_0.observation.obs = json.dumps(to_json(obs["player_0"]))
+            player_1.observation.obs = json.dumps(to_json(obs["player_1"]))
+
+            replay_frame = luxenv.serialize_episode_data(
+                dict(
+                    states=[luxenv.episode["states"][-1]],
+                    metadata=luxenv.episode["metadata"],
+                    params=luxenv.episode["params"],
+                )
+            )
+            # don't need to keep metadata/params beyond first step
+            player_0.info = dict(replay=replay_frame)
+            return state
+
+        # validate actions
+        player_0_valid_action = True
+        player_1_valid_action = True
+
+        def validate_action(action):
+            valid = True
+            if action.shape != (luxenv.action_space["player_0"].shape):
+                valid = False
+            return valid
+
+        try:
+            player_0_action = np.array(player_0.action["action"])
+            assert validate_action(player_0_action)
+        except:
+            player_0_valid_action = False
+            player_0_action = luxenv.action_space.sample()["player_0"] * 0
+
+        try:
+            player_1_action = np.array(player_1.action["action"])
+            assert validate_action(player_1_action)
+        except:
+            player_1_valid_action = False
+            player_1_action = luxenv.action_space.sample()["player_1"] * 0
+
+        new_state_obs, rewards, terminations, truncations, infos = luxenv.step(
+            {"player_0": player_0_action, "player_1": player_1_action}
+        )
+
+        # cannot store np arrays in replay jsons so must convert to list
+        player_0.action = player_0_action.tolist()
+        player_1.action = player_1_action.tolist()
+
+        dones = dict()
+        for k in terminations:
+            dones[k] = terminations[k] | truncations[k]
+
+        player_0.observation.player = "player_0"
+        player_1.observation.player = "player_1"
+
+        player_0.observation.obs = json.dumps(to_json(new_state_obs["player_0"]))
+        player_1.observation.obs = json.dumps(to_json(new_state_obs["player_1"]))
+
+        player_0.reward = int(rewards["player_0"])
+        player_1.reward = int(rewards["player_1"])
+
+        player_0.observation.reward = int(player_0.reward)
+        player_1.observation.reward = int(player_1.reward)
+        replay_frame = luxenv.serialize_episode_data(
+            dict(
+                states=[luxenv.episode["states"][-1]],
+                actions=[luxenv.episode["actions"][-1]],
+                metadata=luxenv.episode["metadata"],
+                params=luxenv.episode["params"],
+            )
+        )
+        # don't need to keep metadata/params beyond first step
+        del replay_frame["metadata"]
+        del replay_frame["params"]
+        player_0.info = dict(replay=replay_frame)
+
+        if np.all([dones[k] for k in dones]):
+            if player_0.status == "ACTIVE":
+                player_0.status = "DONE"
+            if player_1.status == "ACTIVE":
+                player_1.status = "DONE"
+        # if player submits invalid action we need to mark the game as failed.
+        if not player_0_valid_action:
+            player_0.status = "ERROR"
+        if not player_1_valid_action:
+            player_1.status = "ERROR"
+        return state
+    except ModuleNotFoundError as e:
+        print(e)
+        print("Lux AI S3 Dependencies are missing, interpreter will not work")
+    return state
+
+
+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_s3.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_s3/luxai_s3/__init__.py

@@ -0,0 +1 @@
+from .env import LuxAIS3Env