lux-ai-challenge-season-2-tutorial-python.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","execution":{"iopub.execute_input":"2023-01-24T18:02:29.511609Z","iopub.status.busy":"2023-01-24T18:02:29.510799Z","iopub.status.idle":"2023-01-24T18:02:29.548408Z","shell.execute_reply":"2023-01-24T18:02:29.547142Z","shell.execute_reply.started":"2023-01-24T18:02:29.511489Z"}},"source":["# Lux AI Season 2 Tutorial - Python Kit\n","\n","Welcome to Lux AI Season 2!\n","\n","This notebook is the basic setup to use Jupyter Notebooks and the kaggle-environments package to develop your bot. If you plan to not use Jupyter Notebooks or any other programming language, please see our Github. The following are some important links!\n","\n","Competition Page: https://www.kaggle.com/c/lux-ai-season-2/\n","\n","Online Visualizer: https://s2vis.lux-ai.org/\n","\n","Specifications: https://www.lux-ai.org/specs-s2\n","\n","Github: https://github.com/Lux-AI-Challenge/Lux-Design-S2\n","\n","Bot API: https://github.com/Lux-AI-Challenge/Lux-Design-S2/tree/main/kits\n","\n","And if you haven't done so already, we highly recommend you join our Discord server at https://discord.gg/aWJt3UAcgn or at the minimum follow the kaggle forums at https://www.kaggle.com/c/lux-ai-season-2/discussion. We post important announcements there such as changes to rules, events, and opportunities from our sponsors!\n","\n","Now let's get started!"]},{"cell_type":"markdown","metadata":{"execution":{"iopub.status.busy":"2023-01-24T18:02:29.549628Z","iopub.status.idle":"2023-01-24T18:02:29.550292Z","shell.execute_reply":"2023-01-24T18:02:29.550099Z","shell.execute_reply.started":"2023-01-24T18:02:29.550071Z"}},"source":["## Prerequisites\n","We assume that you have a basic knowledge of Python and programming. It's okay if you don't know the game specifications yet! Feel free to always refer back to https://www.lux-ai.org/specs-s2.\n","\n","## Basic Setup\n","First thing to verify is that you have python 3.7 or above and have the [luxai_s2](https://pypi.org/project/luxai_s2/) package installed"]},{"cell_type":"code","execution_count":1,"metadata":{"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Python 3.9.16\n","Requirement already satisfied: luxai_s2 in ./luxEnv/lib/python3.9/site-packages (2.1.4)\n","Requirement already satisfied: omegaconf in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (2.3.0)\n","Requirement already satisfied: scipy in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (1.10.0)\n","Requirement already satisfied: importlib-metadata<5.0 in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (4.13.0)\n","Requirement already satisfied: numpy in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (1.24.1)\n","Requirement already satisfied: pettingzoo in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (1.22.3)\n","Requirement already satisfied: gym==0.21.0 in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (0.21.0)\n","Requirement already satisfied: matplotlib in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (3.6.3)\n","Requirement already satisfied: vec-noise in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (1.1.4)\n","Requirement already satisfied: pygame in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (2.1.2)\n","Requirement already satisfied: termcolor in ./luxEnv/lib/python3.9/site-packages (from luxai_s2) (2.2.0)\n","Requirement already satisfied: cloudpickle>=1.2.0 in ./luxEnv/lib/python3.9/site-packages (from gym==0.21.0->luxai_s2) (2.2.1)\n","Requirement already satisfied: zipp>=0.5 in ./luxEnv/lib/python3.9/site-packages (from importlib-metadata<5.0->luxai_s2) (3.12.0)\n","Requirement already satisfied: cycler>=0.10 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (0.11.0)\n","Requirement already satisfied: kiwisolver>=1.0.1 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (1.4.4)\n","Requirement already satisfied: packaging>=20.0 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (23.0)\n","Requirement already satisfied: pyparsing>=2.2.1 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (3.0.9)\n","Requirement already satisfied: contourpy>=1.0.1 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (1.0.7)\n","Requirement already satisfied: python-dateutil>=2.7 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (2.8.2)\n","Requirement already satisfied: pillow>=6.2.0 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (9.4.0)\n","Requirement already satisfied: fonttools>=4.22.0 in ./luxEnv/lib/python3.9/site-packages (from matplotlib->luxai_s2) (4.38.0)\n","Requirement already satisfied: antlr4-python3-runtime==4.9.* in ./luxEnv/lib/python3.9/site-packages (from omegaconf->luxai_s2) (4.9.3)\n","Requirement already satisfied: PyYAML>=5.1.0 in ./luxEnv/lib/python3.9/site-packages (from omegaconf->luxai_s2) (6.0)\n","Requirement already satisfied: gymnasium>=0.26.0 in ./luxEnv/lib/python3.9/site-packages (from pettingzoo->luxai_s2) (0.27.1)\n","Requirement already satisfied: gymnasium-notices>=0.0.1 in ./luxEnv/lib/python3.9/site-packages (from gymnasium>=0.26.0->pettingzoo->luxai_s2) (0.0.1)\n","Requirement already satisfied: jax-jumpy>=0.2.0 in ./luxEnv/lib/python3.9/site-packages (from gymnasium>=0.26.0->pettingzoo->luxai_s2) (0.2.0)\n","Requirement already satisfied: typing-extensions>=4.3.0 in ./luxEnv/lib/python3.9/site-packages (from gymnasium>=0.26.0->pettingzoo->luxai_s2) (4.4.0)\n","Requirement already satisfied: six>=1.5 in ./luxEnv/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib->luxai_s2) (1.16.0)\n","\n","\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.3.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.0\u001b[0m\n","\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n","Requirement already satisfied: importlib-metadata==4.13.0 in ./luxEnv/lib/python3.9/site-packages (4.13.0)\n","Requirement already satisfied: zipp>=0.5 in ./luxEnv/lib/python3.9/site-packages (from importlib-metadata==4.13.0) (3.12.0)\n","\n","\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.3.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.0\u001b[0m\n","\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n","Requirement already satisfied: moviepy in ./luxEnv/lib/python3.9/site-packages (1.0.3)\n","Requirement already satisfied: numpy>=1.17.3 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (1.24.1)\n","Requirement already satisfied: imageio-ffmpeg>=0.2.0 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (0.4.8)\n","Requirement already satisfied: decorator<5.0,>=4.0.2 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (4.4.2)\n","Requirement already satisfied: imageio<3.0,>=2.5 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (2.25.0)\n","Requirement already satisfied: tqdm<5.0,>=4.11.2 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (4.64.1)\n","Requirement already satisfied: proglog<=1.0.0 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (0.1.10)\n","Requirement already satisfied: requests<3.0,>=2.8.1 in ./luxEnv/lib/python3.9/site-packages (from moviepy) (2.28.2)\n","Requirement already satisfied: pillow>=8.3.2 in ./luxEnv/lib/python3.9/site-packages (from imageio<3.0,>=2.5->moviepy) (9.4.0)\n","Requirement already satisfied: urllib3<1.27,>=1.21.1 in ./luxEnv/lib/python3.9/site-packages (from requests<3.0,>=2.8.1->moviepy) (1.26.14)\n","Requirement already satisfied: charset-normalizer<4,>=2 in ./luxEnv/lib/python3.9/site-packages (from requests<3.0,>=2.8.1->moviepy) (3.0.1)\n","Requirement already satisfied: idna<4,>=2.5 in ./luxEnv/lib/python3.9/site-packages (from requests<3.0,>=2.8.1->moviepy) (3.4)\n","Requirement already satisfied: certifi>=2017.4.17 in ./luxEnv/lib/python3.9/site-packages (from requests<3.0,>=2.8.1->moviepy) (2022.12.7)\n","\n","\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.3.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.0\u001b[0m\n","\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"]}],"source":["# verify version\n","!python --version\n","!pip install --upgrade luxai_s2\n","!pip install importlib-metadata==4.13.0\n","!pip install --upgrade moviepy # needed to render videos of episodes"]},{"cell_type":"code","execution_count":2,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:39:43.846990Z","iopub.status.busy":"2023-01-24T19:39:43.846545Z","iopub.status.idle":"2023-01-24T19:39:45.768603Z","shell.execute_reply":"2023-01-24T19:39:45.767534Z","shell.execute_reply.started":"2023-01-24T19:39:43.846946Z"},"trusted":true},"outputs":[],"source":["from luxai_s2.env import LuxAI_S2\n","import matplotlib.pyplot as plt\n","import numpy as np"]},{"cell_type":"markdown","metadata":{},"source":["We can now create an environment and start interacting with it, as well as look at what the observation is like"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:39:46.052351Z","iopub.status.busy":"2023-01-24T19:39:46.051205Z","iopub.status.idle":"2023-01-24T19:39:46.068702Z","shell.execute_reply":"2023-01-24T19:39:46.067580Z","shell.execute_reply.started":"2023-01-24T19:39:46.052316Z"},"trusted":true},"outputs":[],"source":["env = LuxAI_S2() # create the environment object\n","obs = env.reset(seed=41) # resets an environment with a seed"]},{"cell_type":"code","execution_count":4,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:39:52.623205Z","iopub.status.busy":"2023-01-24T19:39:52.622757Z","iopub.status.idle":"2023-01-24T19:39:52.633998Z","shell.execute_reply":"2023-01-24T19:39:52.632648Z","shell.execute_reply.started":"2023-01-24T19:39:52.623169Z"},"trusted":true},"outputs":[{"data":{"text/plain":["(dict_keys(['player_0', 'player_1']),\n"," dict_keys(['units', 'teams', 'factories', 'board', 'real_env_steps', 'global_id']))"]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["# the observation is always composed of observations for both players.\n","obs.keys(), obs[\"player_0\"].keys()"]},{"cell_type":"markdown","metadata":{},"source":["To visualize the environment, on jupyter notebooks you have two options\n","\n","With the `rgb_array` mode you can visualize every step as an environment episode progresses. \n","\n","With the CLI tool, you can run an episode and save a replay.json to upload to https://s2vis.lux-ai.org/ or a replay.html file to directly open and watch"]},{"cell_type":"code","execution_count":5,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:39:53.800713Z","iopub.status.busy":"2023-01-24T19:39:53.800017Z","iopub.status.idle":"2023-01-24T19:39:54.158812Z","shell.execute_reply":"2023-01-24T19:39:54.157933Z","shell.execute_reply.started":"2023-01-24T19:39:53.800678Z"},"trusted":true},"outputs":[{"data":{"text/plain":["<matplotlib.image.AxesImage at 0x13c67ab80>"]},"execution_count":5,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# visualize the environment so far with rgb_array to get a quick look at the map\n","# dark orange - high rubble, light orange - low rubble\n","# blue = ice, yellow = ore\n","img = env.render(\"rgb_array\", width=640, height=640)\n","plt.imshow(img)"]},{"cell_type":"markdown","metadata":{},"source":["## Building an Agent\n","Now we know what the environment looks like, let's try building a working agent. The goal of this environment to ensure at least one factory stays alive by the end of the episode and grow as much lichen as possible.\n","\n","In our kit we provide a skeleton for building an agent. Avoid removing any function from the kit unless you know what you are doing as it may cause your agent to fail on the competition servers. This agent defintion should be stored in the `agent.py` file.\n","\n","The agent will have `self.player, self.opp_player, self.env_cfg` populated with the correct values at each step of an environment during competition or when you use the CLI tool to run matches. \n","\n","`self.env_cfg` stores the curent environment's configurations, and `self.player, self.opp_player` stores the name of your player/team and the opposition respectively (will always be \"player_0\" or \"player_1\")."]},{"cell_type":"code","execution_count":8,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:40:06.897335Z","iopub.status.busy":"2023-01-24T19:40:06.896924Z","iopub.status.idle":"2023-01-24T19:40:06.909031Z","shell.execute_reply":"2023-01-24T19:40:06.907824Z","shell.execute_reply.started":"2023-01-24T19:40:06.897303Z"},"trusted":true},"outputs":[],"source":["from lux.kit import obs_to_game_state, GameState, EnvConfig\n","from luxai_s2.utils import animate\n","from lux.utils import direction_to, my_turn_to_place_factory\n","class Agent():\n","    def __init__(self, player: str, env_cfg: EnvConfig) -> None:\n","        self.player = player\n","        self.opp_player = \"player_1\" if self.player == \"player_0\" else \"player_0\"\n","        np.random.seed(0)\n","        self.env_cfg: EnvConfig = env_cfg\n","\n","    def early_setup(self, step: int, obs, remainingOverageTime: int = 60):\n","        actions = dict()\n","        # optionally convert observations to python objects with utility functions\n","        game_state = obs_to_game_state(step, self.env_cfg, obs) \n","        return actions\n","\n","    def act(self, step: int, obs, remainingOverageTime: int = 60):\n","        actions = dict()\n","        game_state = obs_to_game_state(step, self.env_cfg, obs)\n","        return actions"]},{"cell_type":"markdown","metadata":{},"source":["Note that in season 2, there are two distinct phases of the game where you will have to program two different sets of logic to play it.\n","\n","We will also define a simple function to initialize our agent and interact with the environment and generate a simple video replay.\n","No need to worry about how this works specifically, you can copy paste this as you see fit. Note that this is a simplified representation. In order to visually see all numbers and details about units, factories etc. use our web visualizer."]},{"cell_type":"code","execution_count":10,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:40:40.163980Z","iopub.status.busy":"2023-01-24T19:40:40.163528Z","iopub.status.idle":"2023-01-24T19:40:40.178043Z","shell.execute_reply":"2023-01-24T19:40:40.176597Z","shell.execute_reply.started":"2023-01-24T19:40:40.163946Z"},"trusted":true},"outputs":[],"source":["def animate(imgs, _return=True):\n","    # using cv2 to generate videos as moviepy doesn't work on kaggle notebooks\n","    import cv2\n","    import os\n","    import string\n","    import random\n","    video_name = ''.join(random.choice(string.ascii_letters) for i in range(18))+'.webm'\n","    height, width, layers = imgs[0].shape\n","    fourcc = cv2.VideoWriter_fourcc(*'VP90')\n","    video = cv2.VideoWriter(video_name, fourcc, 10, (width,height))\n","\n","    for img in imgs:\n","        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n","        video.write(img)\n","    video.release()\n","    if _return:\n","        from IPython.display import Video\n","        return Video(video_name)\n","def interact(env, agents, steps):\n","    # reset our env\n","    obs = env.reset(seed=41)\n","    np.random.seed(0)\n","    imgs = []\n","    step = 0\n","    # Note that as the environment has two phases, we also keep track a value called \n","    # `real_env_steps` in the environment state. The first phase ends once `real_env_steps` is 0 and used below\n","\n","    # iterate until phase 1 ends\n","    while env.state.real_env_steps < 0:\n","        if step >= steps: break\n","        actions = {}\n","        for player in env.agents:\n","            o = obs[player]\n","            a = agents[player].early_setup(step, o)\n","            actions[player] = a\n","        step += 1\n","        obs, rewards, dones, infos = env.step(actions)\n","        imgs += [env.render(\"rgb_array\", width=640, height=640)]\n","    done = False\n","    while not done:\n","        if step >= steps: break\n","        actions = {}\n","        for player in env.agents:\n","            o = obs[player]\n","            a = agents[player].act(step, o)\n","            actions[player] = a\n","        step += 1\n","        obs, rewards, dones, infos = env.step(actions)\n","        imgs += [env.render(\"rgb_array\", width=640, height=640)]\n","        done = dones[\"player_0\"] and dones[\"player_1\"]\n","    return animate(imgs)"]},{"cell_type":"markdown","metadata":{},"source":["### Early Phase\n","\n","During the first turn of the game, each player is given the map, starting resources (N factories and N\\*150 water and ore), and are asked to bid for who goes first/second. Each 1 bid removes 1 water and 1 ore from that player's starting resources. Each player responds in turn 1 with their bid, which can be positive to prefer going first or negative to prefer going second. \n","\n","After bidding you then place each of your factories. Each team gets `N` factories to place, with. For conveniency the observation contains all possible spawn locations for your team which account for the opponent's factories and resource tiles which you can't spawn on.\n","\n","We will write a simple `early_setup` function to return the appropriate action to handle this phase.\n","\n"]},{"cell_type":"code","execution_count":11,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:43:03.880088Z","iopub.status.busy":"2023-01-24T19:43:03.879639Z","iopub.status.idle":"2023-01-24T19:43:03.890188Z","shell.execute_reply":"2023-01-24T19:43:03.888785Z","shell.execute_reply.started":"2023-01-24T19:43:03.880053Z"},"trusted":true},"outputs":[],"source":["def early_setup(self, step: int, obs, remainingOverageTime: int = 60):\n","    if step == 0:\n","        # bid 0 to not waste resources bidding and declare as the default faction\n","        # you can bid -n to prefer going second or n to prefer going first in placement\n","        return dict(faction=\"AlphaStrike\", bid=0)\n","    else:\n","        game_state = obs_to_game_state(step, self.env_cfg, obs)\n","        # factory placement period\n","        \n","        # how much water and metal you have in your starting pool to give to new factories\n","        water_left = game_state.teams[self.player].water\n","        metal_left = game_state.teams[self.player].metal\n","        \n","        # how many factories you have left to place\n","        factories_to_place = game_state.teams[self.player].factories_to_place\n","        # whether it is your turn to place a factory\n","        my_turn_to_place = my_turn_to_place_factory(game_state.teams[self.player].place_first, step)\n","        if factories_to_place > 0 and my_turn_to_place:\n","            # we will spawn our factory in a random location with 150 metal and water if it is our turn to place\n","            potential_spawns = np.array(list(zip(*np.where(obs[\"board\"][\"valid_spawns_mask\"] == 1))))\n","            spawn_loc = potential_spawns[np.random.randint(0, len(potential_spawns))]\n","            return dict(spawn=spawn_loc, metal=150, water=150)\n","        return dict()\n","Agent.early_setup = early_setup"]},{"cell_type":"markdown","metadata":{},"source":["Each team gets `N` factories to place, with. For conveniency the observation contains all possible spawn locations for your team"]},{"cell_type":"code","execution_count":13,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:43:20.020710Z","iopub.status.busy":"2023-01-24T19:43:20.020210Z","iopub.status.idle":"2023-01-24T19:43:22.001899Z","shell.execute_reply":"2023-01-24T19:43:22.000148Z","shell.execute_reply.started":"2023-01-24T19:43:20.020674Z"},"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["OpenCV: FFMPEG: tag 0x30395056/'VP90' is not supported with codec id 167 and format 'webm / WebM'\n"]},{"data":{"text/html":["<video src=\"TRJgEzQckCSxsnVhDR.webm\" controls  >\n","      Your browser does not support the <code>video</code> element.\n","    </video>"],"text/plain":["<IPython.core.display.Video object>"]},"execution_count":13,"metadata":{},"output_type":"execute_result"}],"source":["# recreate our agents and run\n","agents = {player: Agent(player, env.state.env_cfg) for player in env.agents}\n","interact(env, agents, 5)"]},{"cell_type":"markdown","metadata":{},"source":["Congratz, we have lift off! We got both teams to spawn some factories. With the early phase over, we can now start programming the logic to power the next phase.\n","\n","### Regular Phase\n","\n","The goal of the game is to grow more lichen than your opponent by the end of the 1000 step episode (not including early phase steps). To grow lichen factories must consume water. Moreover, factories passively consume 1 water a turn, and you must ensure at least one factory survives until the end. Whichever team loses all their factories first will automatically lose. \n","\n","To obtain water, robots/units must mine ice from ice tiles (blue on the map) and deliver them back to a factory which then automatically refines ice into water. \n","\n","Moreover, to help us write better code, we will use the provided function `obs_to_game_state` to convert observations from raw dictionaries to interactable python objects. Finally, we will also use a provided `animate` function to easily generate a simple video of the episode and embed it into here without having to upload a replay file to the web visualizer."]},{"cell_type":"markdown","metadata":{},"source":["#### Building Robots\n","\n","Only factories can build robots, so for each factory on our team, if there is enough metal and power, we will issue a command to build a new heavy robot.\n","\n","More advanced strategies will be able to efficiently leverage light units as well to collect resources but for simplicity, this tutorial uses heavy robots since they don't need to move as often to collect many resources (albeit very energy inefficient)."]},{"cell_type":"code","execution_count":14,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:44:40.947100Z","iopub.status.busy":"2023-01-24T19:44:40.946428Z","iopub.status.idle":"2023-01-24T19:44:40.954802Z","shell.execute_reply":"2023-01-24T19:44:40.953290Z","shell.execute_reply.started":"2023-01-24T19:44:40.947044Z"},"trusted":true},"outputs":[],"source":["from lux.kit import obs_to_game_state, GameState"]},{"cell_type":"code","execution_count":16,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:44:43.860828Z","iopub.status.busy":"2023-01-24T19:44:43.860415Z","iopub.status.idle":"2023-01-24T19:44:43.869445Z","shell.execute_reply":"2023-01-24T19:44:43.867811Z","shell.execute_reply.started":"2023-01-24T19:44:43.860796Z"},"trusted":true},"outputs":[],"source":["def act(self, step: int, obs, remainingOverageTime: int = 60):\n","    actions = dict()\n","    game_state: GameState = obs_to_game_state(step, self.env_cfg, obs)\n","    factories = game_state.factories[self.player]\n","    for unit_id, factory in factories.items():\n","        if factory.power >= self.env_cfg.ROBOTS[\"HEAVY\"].POWER_COST and \\\n","        factory.cargo.metal >= self.env_cfg.ROBOTS[\"HEAVY\"].METAL_COST:\n","            actions[unit_id] = factory.build_heavy()\n","    return actions\n","Agent.act = act"]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:44:47.928300Z","iopub.status.busy":"2023-01-24T19:44:47.927887Z","iopub.status.idle":"2023-01-24T19:44:52.501069Z","shell.execute_reply":"2023-01-24T19:44:52.499615Z","shell.execute_reply.started":"2023-01-24T19:44:47.928266Z"},"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["OpenCV: FFMPEG: tag 0x30395056/'VP90' is not supported with codec id 167 and format 'webm / WebM'\n"]},{"data":{"text/html":["<video src=\"UPsjVaLHZitCZecmFA.webm\" controls  >\n","      Your browser does not support the <code>video</code> element.\n","    </video>"],"text/plain":["<IPython.core.display.Video object>"]},"execution_count":17,"metadata":{},"output_type":"execute_result"}],"source":["# recreate our agents and run\n","agents = {player: Agent(player, env.state.env_cfg) for player in env.agents}\n","interact(env, agents, 25)"]},{"cell_type":"markdown","metadata":{},"source":["Robots built, but they're idle! Let's get them to work.\n","\n","#### Moving Robots and Mining\n","\n","We want the robots to find the closest ice tile and mine it.\n","We'll worry about delivering the ice back home later. Let's update our `act` function to add this functionality. We will iterate over all our units and find the closest ice tile. Then we will use a given utility function that gives us the direction that takes us towards the desired ice tile. Lastly, we check if we have enough power to move and can move in that direction and submit that action.\n","\n","Importantly, in this season **units are given action queues (a list of actions). Each time an action queue is given, the unit's old action queue is replaced completely in addition to a small additional action queue submission power cost.**\n","\n","**Moreover, each action can be set to be repeated or not, indicating whether to put the action to the back of the queue once completed** For this tutorial, we will be giving units one action at a time and setting it to not be repeated. For future reference, to reduce power costs you can submit longer action queues and only update the action queue every once in a while."]},{"cell_type":"code","execution_count":18,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:45:08.930205Z","iopub.status.busy":"2023-01-24T19:45:08.929774Z","iopub.status.idle":"2023-01-24T19:45:08.943356Z","shell.execute_reply":"2023-01-24T19:45:08.941948Z","shell.execute_reply.started":"2023-01-24T19:45:08.930170Z"},"trusted":true},"outputs":[],"source":["from lux.utils import direction_to\n","import sys\n","def act(self, step: int, obs, remainingOverageTime: int = 60):\n","    actions = dict()\n","    game_state = obs_to_game_state(step, self.env_cfg, obs)\n","    factories = game_state.factories[self.player]\n","    for unit_id, factory in factories.items():\n","        if factory.power >= self.env_cfg.ROBOTS[\"HEAVY\"].POWER_COST and \\\n","        factory.cargo.metal >= self.env_cfg.ROBOTS[\"HEAVY\"].METAL_COST:\n","            actions[unit_id] = factory.build_heavy()\n","            \n","    # iterate over our units and have them mine the closest ice tile\n","    units = game_state.units[self.player]\n","    ice_map = game_state.board.ice # flip the board as it stores by rows then columns\n","    ice_tile_locations = np.argwhere(ice_map == 1) # numpy magic to get the position of every ice tile\n","    for unit_id, unit in units.items():\n","        # compute the distance to each ice tile from this unit and pick the closest\n","        ice_tile_distances = np.mean((ice_tile_locations - unit.pos) ** 2, 1)\n","        closest_ice_tile = ice_tile_locations[np.argmin(ice_tile_distances)]\n","        \n","        # if we have reached the ice tile, start mining if possible\n","        if np.all(closest_ice_tile == unit.pos):\n","            if unit.power >= unit.dig_cost(game_state) + unit.action_queue_cost(game_state):\n","                actions[unit_id] = [unit.dig(repeat=0)]\n","        else:\n","            direction = direction_to(unit.pos, closest_ice_tile)\n","            move_cost = unit.move_cost(game_state, direction)\n","            # check move_cost is not None, meaning that direction is not off the map or blocked\n","            # check if unit has enough power to move in addition to updating the action queue.\n","            if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n","                actions[unit_id] = [unit.move(direction, repeat=0)]\n","        # since we are using the simple embedded visualizer, we will have to print out details about units\n","        # importantly, note that we print with file=sys.stderr. Printing with anything will cause your agent to fail\n","        if unit.cargo.ice > 50:\n","            print(game_state.real_env_steps, unit, f\"has {unit.cargo.ice} ice\", file=sys.stderr)\n","    return actions\n","Agent.act = act"]},{"cell_type":"code","execution_count":16,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:45:13.579154Z","iopub.status.busy":"2023-01-24T19:45:13.578713Z","iopub.status.idle":"2023-01-24T19:45:20.806279Z","shell.execute_reply":"2023-01-24T19:45:20.804924Z","shell.execute_reply.started":"2023-01-24T19:45:13.579119Z"},"trusted":true},"outputs":[{"name":"stderr","output_type":"stream","text":["9 [1] unit_12 HEAVY at [11 11] has 60 ice\n","10 [1] unit_12 HEAVY at [11 11] has 80 ice\n","11 [0] unit_10 HEAVY at [22 34] has 60 ice\n","11 [1] unit_12 HEAVY at [11 11] has 100 ice\n","12 [0] unit_8 HEAVY at [21 46] has 60 ice\n","12 [0] unit_9 HEAVY at [41 14] has 60 ice\n","12 [0] unit_10 HEAVY at [22 34] has 60 ice\n","12 [1] unit_12 HEAVY at [11 11] has 100 ice\n","13 [0] unit_8 HEAVY at [21 46] has 60 ice\n","13 [0] unit_9 HEAVY at [41 14] has 80 ice\n","13 [0] unit_10 HEAVY at [22 34] has 80 ice\n","13 [1] unit_12 HEAVY at [11 11] has 100 ice\n","14 [0] unit_8 HEAVY at [21 46] has 60 ice\n","14 [0] unit_9 HEAVY at [41 14] has 80 ice\n","14 [0] unit_10 HEAVY at [22 34] has 80 ice\n","14 [1] unit_12 HEAVY at [11 11] has 100 ice\n","15 [0] unit_8 HEAVY at [21 46] has 60 ice\n","15 [0] unit_9 HEAVY at [41 14] has 80 ice\n","15 [0] unit_10 HEAVY at [22 34] has 80 ice\n","15 [1] unit_12 HEAVY at [11 11] has 100 ice\n","16 [0] unit_8 HEAVY at [21 46] has 80 ice\n","16 [0] unit_9 HEAVY at [41 14] has 100 ice\n","16 [0] unit_10 HEAVY at [22 34] has 80 ice\n","16 [1] unit_12 HEAVY at [11 11] has 100 ice\n","17 [0] unit_8 HEAVY at [21 46] has 80 ice\n","17 [0] unit_9 HEAVY at [41 14] has 100 ice\n","17 [0] unit_10 HEAVY at [22 34] has 80 ice\n","17 [1] unit_12 HEAVY at [11 11] has 120 ice\n","18 [0] unit_8 HEAVY at [21 46] has 80 ice\n","18 [0] unit_9 HEAVY at [41 14] has 100 ice\n","18 [0] unit_10 HEAVY at [22 34] has 80 ice\n","18 [1] unit_12 HEAVY at [11 11] has 120 ice\n","19 [0] unit_8 HEAVY at [21 46] has 80 ice\n","19 [0] unit_9 HEAVY at [41 14] has 100 ice\n","19 [0] unit_10 HEAVY at [22 34] has 80 ice\n","19 [1] unit_12 HEAVY at [11 11] has 120 ice\n","19 [1] unit_14 HEAVY at [22 26] has 60 ice\n","20 [0] unit_8 HEAVY at [21 46] has 80 ice\n","20 [0] unit_9 HEAVY at [41 14] has 100 ice\n","20 [0] unit_10 HEAVY at [22 34] has 100 ice\n","20 [1] unit_12 HEAVY at [11 11] has 120 ice\n","20 [1] unit_14 HEAVY at [22 26] has 60 ice\n","21 [0] unit_8 HEAVY at [21 46] has 80 ice\n","21 [0] unit_9 HEAVY at [41 14] has 100 ice\n","21 [0] unit_10 HEAVY at [22 34] has 100 ice\n","21 [1] unit_12 HEAVY at [11 11] has 120 ice\n","21 [1] unit_14 HEAVY at [22 26] has 60 ice\n","22 [0] unit_8 HEAVY at [21 46] has 80 ice\n","22 [0] unit_9 HEAVY at [41 14] has 100 ice\n","22 [0] unit_10 HEAVY at [22 34] has 100 ice\n","22 [1] unit_12 HEAVY at [11 11] has 120 ice\n","22 [1] unit_14 HEAVY at [22 26] has 60 ice\n","23 [0] unit_8 HEAVY at [21 46] has 100 ice\n","23 [0] unit_9 HEAVY at [41 14] has 120 ice\n","23 [0] unit_10 HEAVY at [22 34] has 100 ice\n","23 [1] unit_12 HEAVY at [11 11] has 120 ice\n","23 [1] unit_14 HEAVY at [22 26] has 60 ice\n","24 [0] unit_8 HEAVY at [21 46] has 100 ice\n","24 [0] unit_9 HEAVY at [41 14] has 120 ice\n","24 [0] unit_10 HEAVY at [22 34] has 100 ice\n","24 [1] unit_12 HEAVY at [11 11] has 140 ice\n","24 [1] unit_14 HEAVY at [22 26] has 60 ice\n","25 [0] unit_8 HEAVY at [21 46] has 100 ice\n","25 [0] unit_9 HEAVY at [41 14] has 120 ice\n","25 [0] unit_10 HEAVY at [22 34] has 100 ice\n","25 [1] unit_12 HEAVY at [11 11] has 140 ice\n","25 [1] unit_14 HEAVY at [22 26] has 60 ice\n","26 [0] unit_8 HEAVY at [21 46] has 100 ice\n","26 [0] unit_9 HEAVY at [41 14] has 120 ice\n","26 [0] unit_10 HEAVY at [22 34] has 100 ice\n","26 [1] unit_12 HEAVY at [11 11] has 140 ice\n","26 [1] unit_14 HEAVY at [22 26] has 80 ice\n","27 [0] unit_8 HEAVY at [21 46] has 100 ice\n","27 [0] unit_9 HEAVY at [41 14] has 120 ice\n","27 [0] unit_10 HEAVY at [22 34] has 120 ice\n","27 [1] unit_12 HEAVY at [11 11] has 140 ice\n","27 [1] unit_14 HEAVY at [22 26] has 80 ice\n","28 [0] unit_8 HEAVY at [21 46] has 100 ice\n","28 [0] unit_9 HEAVY at [41 14] has 120 ice\n","28 [0] unit_10 HEAVY at [22 34] has 120 ice\n","28 [1] unit_12 HEAVY at [11 11] has 140 ice\n","28 [1] unit_14 HEAVY at [22 26] has 80 ice\n","29 [0] unit_8 HEAVY at [21 46] has 100 ice\n","29 [0] unit_9 HEAVY at [41 14] has 120 ice\n","29 [0] unit_10 HEAVY at [22 34] has 120 ice\n","29 [1] unit_12 HEAVY at [11 11] has 140 ice\n","29 [1] unit_14 HEAVY at [22 26] has 80 ice\n","30 [0] unit_8 HEAVY at [21 46] has 120 ice\n","30 [0] unit_9 HEAVY at [41 14] has 140 ice\n","30 [0] unit_10 HEAVY at [22 34] has 120 ice\n","30 [1] unit_12 HEAVY at [11 11] has 140 ice\n","30 [1] unit_14 HEAVY at [22 26] has 80 ice\n","OpenCV: FFMPEG: tag 0x30395056/'VP90' is not supported with codec id 167 and format 'webm / WebM'\n"]},{"data":{"text/html":["<video src=\"MvIRpcatjhdOvVIMrZ.webm\" controls  >\n","      Your browser does not support the <code>video</code> element.\n","    </video>"],"text/plain":["<IPython.core.display.Video object>"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["# recreate our agents and run\n","agents = {player: Agent(player, env.state.env_cfg) for player in env.agents}\n","interact(env, agents, steps=40)"]},{"cell_type":"markdown","metadata":{},"source":["And they're off! The heavy robots have started to move towards the ice tiles and some have begun mining.\n","\n","#### Delivering Resources and Keep Factories Alive\n","We now have ice being mined, but we now need to deliver that back to the factories so they can refine that ice into water and sustain themselves."]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:45:43.271329Z","iopub.status.busy":"2023-01-24T19:45:43.269909Z","iopub.status.idle":"2023-01-24T19:45:43.293813Z","shell.execute_reply":"2023-01-24T19:45:43.292379Z","shell.execute_reply.started":"2023-01-24T19:45:43.271269Z"},"trusted":true},"outputs":[],"source":["def act(self, step: int, obs, remainingOverageTime: int = 60):\n","    actions = dict()\n","    game_state = obs_to_game_state(step, self.env_cfg, obs)\n","    factories = game_state.factories[self.player]\n","    factory_tiles, factory_units = [], []\n","    for unit_id, factory in factories.items():\n","        if factory.power >= self.env_cfg.ROBOTS[\"HEAVY\"].POWER_COST and \\\n","        factory.cargo.metal >= self.env_cfg.ROBOTS[\"HEAVY\"].METAL_COST:\n","            actions[unit_id] = factory.build_heavy()\n","        factory_tiles += [factory.pos]\n","        factory_units += [factory]\n","    factory_tiles = np.array(factory_tiles)\n","\n","    units = game_state.units[self.player]\n","    ice_map = game_state.board.ice\n","    ice_tile_locations = np.argwhere(ice_map == 1)\n","    for unit_id, unit in units.items():\n","        \n","        # track the closest factory\n","        closest_factory = None\n","        adjacent_to_factory = False\n","        if len(factory_tiles) > 0:\n","            factory_distances = np.mean((factory_tiles - unit.pos) ** 2, 1)\n","            closest_factory_tile = factory_tiles[np.argmin(factory_distances)]\n","            closest_factory = factory_units[np.argmin(factory_distances)]\n","            adjacent_to_factory = np.mean((closest_factory_tile - unit.pos) ** 2) == 0\n","        \n","            # previous ice mining code\n","            if unit.cargo.ice < 40:\n","                ice_tile_distances = np.mean((ice_tile_locations - unit.pos) ** 2, 1)\n","                closest_ice_tile = ice_tile_locations[np.argmin(ice_tile_distances)]\n","                if np.all(closest_ice_tile == unit.pos):\n","                    if unit.power >= unit.dig_cost(game_state) + unit.action_queue_cost(game_state):\n","                        actions[unit_id] = [unit.dig(repeat=0)]\n","                else:\n","                    direction = direction_to(unit.pos, closest_ice_tile)\n","                    move_cost = unit.move_cost(game_state, direction)\n","                    if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n","                        actions[unit_id] = [unit.move(direction, repeat=0)]\n","            # else if we have enough ice, we go back to the factory and dump it.\n","            elif unit.cargo.ice >= 40:\n","                direction = direction_to(unit.pos, closest_factory_tile)\n","                if adjacent_to_factory:\n","                    if unit.power >= unit.action_queue_cost(game_state):\n","                        actions[unit_id] = [unit.transfer(direction, 0, unit.cargo.ice, repeat=0)]\n","                else:\n","                    move_cost = unit.move_cost(game_state, direction)\n","                    if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n","                        actions[unit_id] = [unit.move(direction, repeat=0)]\n","    return actions\n","Agent.act = act"]},{"cell_type":"code","execution_count":18,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:46:04.547457Z","iopub.status.busy":"2023-01-24T19:46:04.546378Z","iopub.status.idle":"2023-01-24T19:46:37.196058Z","shell.execute_reply":"2023-01-24T19:46:37.194690Z","shell.execute_reply.started":"2023-01-24T19:46:04.547421Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["65: 1 Units: (unit_13) collided at 22,34 with \u001b[33m[0] unit_10 UnitType.HEAVY at (22, 34)\u001b[0m surviving with 1 power\n","170: player_0 lost all factories\n"]},{"name":"stderr","output_type":"stream","text":["OpenCV: FFMPEG: tag 0x30395056/'VP90' is not supported with codec id 167 and format 'webm / WebM'\n"]},{"data":{"text/html":["<video src=\"KqohmcMeVcAighWALB.webm\" controls  >\n","      Your browser does not support the <code>video</code> element.\n","    </video>"],"text/plain":["<IPython.core.display.Video object>"]},"execution_count":18,"metadata":{},"output_type":"execute_result"}],"source":["# recreate our agents and run\n","agents = {player: Agent(player, env.state.env_cfg) for player in env.agents}\n","interact(env, agents, 300)"]},{"cell_type":"markdown","metadata":{},"source":["Some factories are surviving for for more than 100 steps thanks to the delivery of additional ice, but more work will need to be done to keep them alive longer.\n","\n","Puting all those pieces together the full starter agent looks like this (and we will save it to agent.py)"]},{"cell_type":"code","execution_count":19,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:47:42.499658Z","iopub.status.busy":"2023-01-24T19:47:42.499176Z","iopub.status.idle":"2023-01-24T19:47:42.510391Z","shell.execute_reply":"2023-01-24T19:47:42.509468Z","shell.execute_reply.started":"2023-01-24T19:47:42.499624Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Overwriting agent.py\n"]}],"source":["%%writefile agent.py\n","from lux.kit import obs_to_game_state, GameState, EnvConfig\n","from lux.utils import direction_to, my_turn_to_place_factory\n","import numpy as np\n","import sys\n","class Agent():\n","    def __init__(self, player: str, env_cfg: EnvConfig) -> None:\n","        self.player = player\n","        self.opp_player = \"player_1\" if self.player == \"player_0\" else \"player_0\"\n","        np.random.seed(0)\n","        self.env_cfg: EnvConfig = env_cfg\n","\n","    def early_setup(self, step: int, obs, remainingOverageTime: int = 60):\n","        if step == 0:\n","            # bid 0 to not waste resources bidding and declare as the default faction\n","            return dict(faction=\"AlphaStrike\", bid=0)\n","        else:\n","            game_state = obs_to_game_state(step, self.env_cfg, obs)\n","            # factory placement period\n","\n","            # how much water and metal you have in your starting pool to give to new factories\n","            water_left = game_state.teams[self.player].water\n","            metal_left = game_state.teams[self.player].metal\n","\n","            # how many factories you have left to place\n","            factories_to_place = game_state.teams[self.player].factories_to_place\n","            # whether it is your turn to place a factory\n","            my_turn_to_place = my_turn_to_place_factory(game_state.teams[self.player].place_first, step)\n","            if factories_to_place > 0 and my_turn_to_place:\n","                # we will spawn our factory in a random location with 150 metal and water if it is our turn to place\n","                potential_spawns = np.array(list(zip(*np.where(obs[\"board\"][\"valid_spawns_mask\"] == 1))))\n","                spawn_loc = potential_spawns[np.random.randint(0, len(potential_spawns))]\n","                return dict(spawn=spawn_loc, metal=150, water=150)\n","            return dict()\n","\n","    def act(self, step: int, obs, remainingOverageTime: int = 60):\n","        actions = dict()\n","        game_state = obs_to_game_state(step, self.env_cfg, obs)\n","        factories = game_state.factories[self.player]\n","        game_state.teams[self.player].place_first\n","        factory_tiles, factory_units = [], []\n","        for unit_id, factory in factories.items():\n","            if factory.power >= self.env_cfg.ROBOTS[\"HEAVY\"].POWER_COST and \\\n","            factory.cargo.metal >= self.env_cfg.ROBOTS[\"HEAVY\"].METAL_COST:\n","                actions[unit_id] = factory.build_heavy()\n","            if self.env_cfg.max_episode_length - game_state.real_env_steps < 50:\n","                if factory.water_cost(game_state) <= factory.cargo.water:\n","                    actions[unit_id] = factory.water()\n","            factory_tiles += [factory.pos]\n","            factory_units += [factory]\n","        factory_tiles = np.array(factory_tiles)\n","\n","        units = game_state.units[self.player]\n","        ice_map = game_state.board.ice\n","        ice_tile_locations = np.argwhere(ice_map == 1)\n","        for unit_id, unit in units.items():\n","\n","            # track the closest factory\n","            closest_factory = None\n","            adjacent_to_factory = False\n","            if len(factory_tiles) > 0:\n","                factory_distances = np.mean((factory_tiles - unit.pos) ** 2, 1)\n","                closest_factory_tile = factory_tiles[np.argmin(factory_distances)]\n","                closest_factory = factory_units[np.argmin(factory_distances)]\n","                adjacent_to_factory = np.mean((closest_factory_tile - unit.pos) ** 2) == 0\n","\n","                # previous ice mining code\n","                if unit.cargo.ice < 40:\n","                    ice_tile_distances = np.mean((ice_tile_locations - unit.pos) ** 2, 1)\n","                    closest_ice_tile = ice_tile_locations[np.argmin(ice_tile_distances)]\n","                    if np.all(closest_ice_tile == unit.pos):\n","                        if unit.power >= unit.dig_cost(game_state) + unit.action_queue_cost(game_state):\n","                            actions[unit_id] = [unit.dig(repeat=0)]\n","                    else:\n","                        direction = direction_to(unit.pos, closest_ice_tile)\n","                        move_cost = unit.move_cost(game_state, direction)\n","                        if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n","                            actions[unit_id] = [unit.move(direction, repeat=0)]\n","                # else if we have enough ice, we go back to the factory and dump it.\n","                elif unit.cargo.ice >= 40:\n","                    direction = direction_to(unit.pos, closest_factory_tile)\n","                    if adjacent_to_factory:\n","                        if unit.power >= unit.action_queue_cost(game_state):\n","                            actions[unit_id] = [unit.transfer(direction, 0, unit.cargo.ice, repeat=0)]\n","                    else:\n","                        move_cost = unit.move_cost(game_state, direction)\n","                        if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n","                            actions[unit_id] = [unit.move(direction, repeat=0)]\n","        return actions"]},{"cell_type":"markdown","metadata":{},"source":["## Create a submission\n","Now we need to create a .tar.gz file with main.py (and agent.py) at the top level. We can then upload this!"]},{"cell_type":"code","execution_count":20,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:48:00.139465Z","iopub.status.busy":"2023-01-24T19:48:00.138997Z","iopub.status.idle":"2023-01-24T19:48:01.471618Z","shell.execute_reply":"2023-01-24T19:48:01.469711Z","shell.execute_reply.started":"2023-01-24T19:48:00.139430Z"},"trusted":true},"outputs":[],"source":["!tar -czf submission.tar.gz *"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["## Submit\n","Now open the /kaggle/working folder and find submission.tar.gz, download that file, navigate to the \"MySubmissions\" tab in https://www.kaggle.com/c/lux-ai-season-2/ and upload your submission! It should play a validation match against itself and once it succeeds it will be automatically matched against other players' submissions. Newer submissions will be prioritized for games over older ones. Your team is limited in the number of succesful submissions per day so we highly recommend testing your bot locally before submitting."]},{"cell_type":"markdown","metadata":{},"source":["## CLI Tool\n","\n","To test your agent without using the python API you can also run"]},{"cell_type":"code","execution_count":21,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:48:30.388487Z","iopub.status.busy":"2023-01-24T19:48:30.388006Z","iopub.status.idle":"2023-01-24T19:48:37.207607Z","shell.execute_reply":"2023-01-24T19:48:37.205935Z","shell.execute_reply.started":"2023-01-24T19:48:30.388447Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["10: 1 Units: (unit_12) collided at 26,43 with \u001b[33m[0] unit_10 UnitType.HEAVY at (26, 43)\u001b[0m surviving with 105 power\n","28: 1 Units: (unit_10) collided at 27,43 with \u001b[33m[1] unit_15 UnitType.HEAVY at (27, 43)\u001b[0m surviving with 5 power\n","51: 1 Units: (unit_13) collided at 26,43 with \u001b[33m[1] unit_15 UnitType.HEAVY at (26, 43)\u001b[0m surviving with 5 power\n","160: player_0 lost all factories\n","1.4739747047424316\n"]}],"source":["!luxai-s2 main.py main.py -v 2 -s 101 -o replay.html"]},{"cell_type":"markdown","metadata":{},"source":["which uses a random seed and generates a replay.html file that you can click and watch. Optionally if you specify `-o replay.json` you can upload replay.json to http://s2vis.lux-ai.org/.\n","\n","The CLI tool enables you to easily run episodes between any two agents (python or not) and provides a flexible tournament running tool to evaluate many agents together. Documentation on this tool can be found here: https://github.com/Lux-AI-Challenge/Lux-Design-S2/tree/main/luxai_runner/README.md"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-01-24T19:50:03.841109Z","iopub.status.busy":"2023-01-24T19:50:03.840662Z","iopub.status.idle":"2023-01-24T19:50:03.859821Z","shell.execute_reply":"2023-01-24T19:50:03.858195Z","shell.execute_reply.started":"2023-01-24T19:50:03.841075Z"},"trusted":true},"outputs":[],"source":["import IPython\n","IPython.display.HTML(filename='replay.html')"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"luxEnv","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.9.16"},"vscode":{"interpreter":{"hash":"92db219357ff4fecf0d184055fff2ebab3d419e5f9b85475facebf56604c91a2"}}},"nbformat":4,"nbformat_minor":4}