Raw Code

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "fd9debd6",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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",
      "id": "75339acc",
      "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"
        },
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "## 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. Run the command below to do so. If you are using Kaggle Notebooks, **make sure to also click run-> restart and clear cell outputs** on the top right next to view and add-ons. (This fixes a bug where Kaggle Notebooks loads an incompatible package)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "26688963",
      "metadata": {
        "_kg_hide-input": true,
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "scrolled": true,
        "tags": []
      },
      "outputs": [],
      "source": [
        "# verify version\n",
        "!python --version\n",
        "!pip install --upgrade luxai_s2\n",
        "!pip install gym==0.19\n",
        "!cp -r ../input/lux-ai-season-2/* ."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "d7cb6ee3",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "%%writefile /opt/conda/lib/python3.7/site-packages/luxai_s2/version.py\n",
        "__version__ = \"\"\n",
        "# this code above is used for Kaggle Notebooks\n",
        "# You might not need to run this but if you get an attribute error about the gym package, run it"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ebcf4362",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "Once the above is installed, make sure to restart and clear cell outputs otherwise the code below won't run. Once that is done we can get started!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6b1c61eb",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "from luxai_s2.env import LuxAI_S2\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "983d3530",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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",
        "import gym"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ac007bdb",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "import pandas as pd"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e971be96",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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()\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",
      "id": "d3a7d775",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "d3cc42d8",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "c201a5b6",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "#przyklad slownika\n",
        "# stolice = {'Polska':'Warszawa', 'Singapur': 'Singapur_miasto'}\n",
        "\n",
        "# slownik = dict()\n",
        "# slownik['Niemcy'] = 'Berlin'\n",
        "# slownik['Polska'] = 'Warszawa'\n",
        "\n",
        "# slownik"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dfa84779",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# the observation is always composed of observations for both players.\n",
        "obs.keys(), obs[\"player_0\"].keys()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e470404a",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "env.agents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "80b8549f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "env.state.env_cfg"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c47d8f28",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "### Lokalizacja startowa"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "66eebc2b",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "2f6472a1",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "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",
        "map_rendered = env.render(\"rgb_array\", width=1000, height=1000)\n",
        "plt.imshow(map_rendered)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "20da5cd3",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "ice = obs[\"player_0\"][\"board\"][\"ice\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "235dad51",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "type(ice)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c26aa907",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "ice.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2463937b",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "plt.imshow(ice)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fb88b12f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "from scipy.ndimage import distance_transform_cdt\n",
        "\n",
        "def manhattan_distance(binary_mask):\n",
        "    # Get the distance map from every pixel to the nearest positive pixel\n",
        "    distance_map = distance_transform_cdt(binary_mask, metric='taxicab')\n",
        "    return distance_map"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "59c95b83",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "dist_ice = manhattan_distance(1-ice)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "090f7c4e",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "dist_ice"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e8aa79a4",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))\n",
        "im1 = ax1.imshow(map_rendered )\n",
        "ax1.set_title('map')\n",
        "im2 = ax2.imshow(ice)\n",
        "ax2.set_title(\"ice\")\n",
        "im3 = ax3.imshow(dist_ice)\n",
        "ax3.set_title(\"distance to the closest ice\")\n",
        "fig.colorbar(im3, ax=ax3)\n",
        "plt.figure(dpi=150)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3e2cdb44",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "valid_spawn_locations = obs[\"player_0\"][\"board\"][\"valid_spawns_mask\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9fd20426",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "valid_spawn_locations.shape, dist_ice.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e6a49e39",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "valid_spawn_locations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b6b81d55",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "dist_ice"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7cbc2e81",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "valid_spawn_locations*dist_ice"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f72e834b",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "dist_ice"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e682f3fe",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "dist_ice.max()-dist_ice"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9e529cbb",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))\n",
        "im1 = ax1.imshow(valid_spawn_locations)\n",
        "ax1.set_title('valid spawn locations')\n",
        "im2 = ax2.imshow(dist_ice)\n",
        "ax2.set_title(\"distance to ice\")\n",
        "start_map = valid_spawn_locations*(dist_ice.max()-dist_ice)\n",
        "im3 = ax3.imshow(start_map)\n",
        "ax3.set_title(\"valid spawn locations x distance to ice\")\n",
        "fig.colorbar(im3, ax=ax3)\n",
        "plt.figure(dpi=150)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "180dacda",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "start_map"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f1169dc5",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "start_map.max()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "711b7f2f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "start_map==start_map.max()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "beb3e9f8",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "np.argwhere(start_map==start_map.max())[:2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e7298452",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "start_loc_candidates = np.argwhere(start_map==start_map.max())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "643805a4",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "start_loc_candidates[:5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7dbd5971",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(18, 5))\n",
        "im1 = ax1.imshow(valid_spawn_locations)\n",
        "ax1.set_title('valid spawn locations')\n",
        "im2 = ax2.imshow(dist_ice)\n",
        "ax2.set_title(\"distance to ice\")\n",
        "start_map = valid_spawn_locations*(dist_ice.max()-dist_ice)\n",
        "im3 = ax3.imshow(start_map)\n",
        "spawn_map = np.zeros((48,48))\n",
        "for i in start_loc_candidates:\n",
        "    x= i[0]\n",
        "    y= i[1]\n",
        "    spawn_map[x,y]=100\n",
        "im4 = ax4.imshow(spawn_map)\n",
        "\n",
        "ax4.set_title(\"spawn map\")\n",
        "fig.colorbar(im4, ax=ax4)\n",
        "plt.figure(dpi=150)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e2e1c4c2",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "potential_spawns = np.array(list(zip(*np.where(obs['player_0'][\"board\"][\"valid_spawns_mask\"] == 1))))\n",
        "spawn_loc = start_loc_candidates[np.random.randint(0, len(start_loc_candidates))]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b70b227e",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "rubble = obs[\"player_0\"][\"board\"][\"rubble\"].copy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "847ee0cf",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "start_loc_candidates[7]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ab8b6235",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "sp_x, sp_y = start_loc_candidates[0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ebb06f1e",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble = rubble[sp_x-2:sp_x+3,sp_y-2:sp_y+3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a3c33af6",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ef74f92d",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble[1:4,1:4]=100"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4aa2dd85",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "853afae2",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "(close_rubble == 0).mean()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ab95f22f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble[]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "4a31596f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "rubble = obs[\"player_0\"][\"board\"][\"rubble\"]\n",
        "spawn_candidate_scores = {}\n",
        "for i, spawn_loc_candidate in enumerate(start_loc_candidates):\n",
        "    sp_x, sp_y = spawn_loc_candidate\n",
        "    rub_range = 2\n",
        "    close_rubble_map = rubble[sp_x-rub_range:sp_x+rub_range+1, sp_y-rub_range:sp_y+rub_range+1]\n",
        "    score = (close_rubble_map==0).mean()\n",
        "    spawn_candidate_scores[i]=score\n",
        "    #if i > 4: break\n",
        "\n",
        "key_of_best_candidate = max(spawn_candidate_scores, key=spawn_candidate_scores.get)\n",
        "spawn_loc =start_loc_candidates[key_of_best_candidate]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "513611ff",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble_map[1:4,1:4] = 100\n",
        "close_rubble_map[0,0] = 100\n",
        "close_rubble_map[0,4] = 100\n",
        "close_rubble_map[4,0] = 100\n",
        "close_rubble_map[4,4] = 100"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b61da7d3",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "close_rubble_map "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2ef8643f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "spawn_loc"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2f5ac3ae",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "from scipy.ndimage import distance_transform_cdt\n",
        "\n",
        "def manhattan_distance(binary_mask):\n",
        "    # Get the distance map from every pixel to the nearest positive pixel\n",
        "    distance_map = distance_transform_cdt(binary_mask, metric='taxicab')\n",
        "    return distance_map\n",
        "\n",
        "valid_spawn_locations = obs[\"player_0\"][\"board\"][\"valid_spawns_mask\"]\n",
        "ice = obs[\"player_0\"][\"board\"][\"ice\"]\n",
        "dist_ice = manhattan_distance(1-ice)\n",
        "start_map = valid_spawn_locations*(dist_ice.max()-dist_ice)\n",
        "start_loc_candidates = np.argwhere(start_map==start_map.max())\n",
        "spawn_loc = start_loc_candidates[np.random.randint(0, len(start_loc_candidates))]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9453a19d",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "# Wprowadzenie do klas"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "98521add",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# create a class\n",
        "class Room:\n",
        "    length = 0.0\n",
        "    breadth = 0.0\n",
        "    def calculate_area(self): #a method to calculate area\n",
        "        print(\"Area of Room =\", self.length * self.breadth)\n",
        "\n",
        "# create object of Room class\n",
        "study_room = Room()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1f1abecb",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# assign values to all the attributes \n",
        "study_room.length = 5\n",
        "study_room.breadth = 5\n",
        "\n",
        "# access method inside class\n",
        "study_room.calculate_area()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c8ccaf92",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "aa2e1601",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "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",
      "id": "41286b39",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": "markdown",
      "id": "f772102f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "bccb8607",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "dict(faction=\"AlphaStrike\", bid=0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f276ef48",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "np.random.randint(0, 10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2cec5007",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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",
        "        # 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",
        "        \n",
        "        return dict()\n",
        "Agent.early_setup = early_setup"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0fa037f4",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "6d5039d2",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# recreate our agents and run\n",
        "agents = {player: Agent(player, env.state.env_cfg) for player in env.agents}\n",
        "interact(env, agents, 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "40f49a9e",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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",
      "id": "fa13b7bc",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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 but can collect many at a time."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "b8e900b6",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "#from lux.kit import obs_to_game_state, GameState"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1c358cf7",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "slownik.items()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "78be4fa0",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "for unit_id, factory in slownik.items():\n",
        "    print(unit_id, factory)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6330e7c3",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "env.state.env_cfg.ROBOTS[\"HEAVY\"].POWER_COST"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c68b640e",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "env.state.env_cfg.ROBOTS[\"HEAVY\"].METAL_COST"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "49ed877a",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "zespoly =[['Pawel','Janek', 'Ola'],\n",
        "['Julek', 'MAciek','Anna']]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "127ee7ca",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "for a,b,c in zespoly:\n",
        "    print(a,b,c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2acd0ab5",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "7f967578",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "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",
      "id": "ab6f2315",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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 has two other attributes, its execution count `n` and `repeat`. Each time the action is succesfully executed, we decrement `n` by 1. If `n` hits 0, we remove the action from the action queue. If `repeat == 0`, then we don't recycle the action. If `repeat > 0`, then we **recycle the same action to the back of the action queue** but this time with `n = repeat`.\n",
        "\n",
        "For this tutorial, we will be giving units one action at a time with no action recycling or multiple executions. For more advanced competitors, to reduce power costs you may want to submit longer action queues and only update the action queue every once in a while."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "acd6d18e",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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=1)]\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=1)]\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": null,
      "id": "4c6ca28b",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "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",
      "id": "a897b8f2",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "668982ea",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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=1)]\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=1)]\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=1)]\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=1)]\n",
        "    return actions\n",
        "Agent.act = act"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8888ec01",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "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",
      "id": "be58e325",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "Some factories are surviving for for more than 150 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": "markdown",
      "id": "1c067dc6",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "#### Before hunting (Macro)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "06cb22c4",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "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",
        "from scipy.ndimage import distance_transform_cdt\n",
        "\n",
        "def manhattan_distance(binary_mask):\n",
        "    distance_map = distance_transform_cdt(binary_mask, metric='taxicab')\n",
        "    return distance_map\n",
        "\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=2)\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",
        "            \n",
        "                valid_spawn_locations = obs[\"board\"][\"valid_spawns_mask\"]\n",
        "                ice = obs[\"board\"][\"ice\"]\n",
        "                dist_ice = manhattan_distance(1-ice)\n",
        "                start_map = valid_spawn_locations*(dist_ice.max()-dist_ice)\n",
        "                start_loc_candidates = np.argwhere(start_map==start_map.max())\n",
        "#                 spawn_loc = start_loc_candidates[np.random.randint(0, len(start_loc_candidates))]\n",
        "                \n",
        "                rubble = obs[\"board\"][\"rubble\"]\n",
        "                rub_range = 2\n",
        "                spawn_candidate_scores = {}\n",
        "                for i, spawn_loc_candidate in enumerate(start_loc_candidates):\n",
        "                    sp_x, sp_y = spawn_loc_candidate\n",
        "                    close_rubble_map = rubble[sp_x-rub_range:sp_x+rub_range+1, sp_y-rub_range:sp_y+rub_range+1]                    \n",
        "                    try:\n",
        "                        close_rubble_map[1:4,1:4] = 100\n",
        "                        close_rubble_map[0,0] = 100\n",
        "                        close_rubble_map[0,4] = 100\n",
        "                        close_rubble_map[4,0] = 100\n",
        "                        close_rubble_map[4,4] = 100\n",
        "                    except:\n",
        "                        pass\n",
        "                    score = (close_rubble_map==0).mean()\n",
        "                    spawn_candidate_scores[i]=score\n",
        "\n",
        "                key_of_best_candidate = max(spawn_candidate_scores, key=spawn_candidate_scores.get)\n",
        "                spawn_loc =start_loc_candidates[key_of_best_candidate]\n",
        "\n",
        "                return dict(spawn=spawn_loc, metal=150, water=150)\n",
        "\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 < 200) and (factory.cargo.water > 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",
        "            #basic stats\n",
        "            \n",
        "                       # jak konczy sie gra to roboty dzialaja do konca\n",
        "            if (self.env_cfg.max_episode_length - game_state.real_env_steps > 100)\n",
        "                battery_capacity = 150 if unit.unit_type == \"LIGHT\" else 3000\n",
        "            else\n",
        "                battery_capacity = 50 if unit.unit_type == \"LIGHT\" else 3000 \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.power < battery_capacity*0.1) & adjacent_to_factory:\n",
        "                    actions[unit_id] = [unit.pickup(4, battery_capacity-unit.power)]\n",
        "                elif unit.cargo.ice < 100:\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=1)]\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=1)]\n",
        "                # else if we have enough ice, we go back to the factory and dump it.\n",
        "                elif unit.cargo.ice >= 100:\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=1)]\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=1)]\n",
        "        return actions        "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2561181f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Praca domowa 20.03.2023\n",
        "# - Wyslac powyzszego bota na leaderboard"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47fea5a3",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "#### With hunting"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1d9eea14",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "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 pandas as pd\n",
        "import sys\n",
        "from scipy.ndimage import distance_transform_cdt\n",
        "\n",
        "def manhattan_distance(binary_mask):\n",
        "    distance_map = distance_transform_cdt(binary_mask, metric='taxicab')\n",
        "    return distance_map\n",
        "\n",
        "# direction (0 = center, 1 = up, 2 = right, 3 = down, 4 = left)\n",
        "move_arrays = {1: np.array([0, -1]), 2: np.array([1, 0]), 3: np.array([0, 1]), 4: np.array([-1, 0])}\n",
        "def direction_to_mod_2(src, target, opp_factories_map, step, step_thr = 20):\n",
        "    move_signs_hor = {1: 2, -1: 4}\n",
        "    move_signs_vert = {1: 3, -1: 1}\n",
        "\n",
        "    move_dict_vert = {1:-1, 3:1}\n",
        "    move_dict_hor = {2:1, 4:-1}\n",
        "    ds = target - src\n",
        "    dx = ds[0]\n",
        "    dy = ds[1]\n",
        " \n",
        "    if dx == 0 and dy == 0:\n",
        "        move_candidate = 0\n",
        "        pos_after = src\n",
        "    if dx > 0:\n",
        "        move_candidate_x = 2\n",
        "        pos_after_x = src + np.array([1,0])\n",
        "    elif dx < 0:\n",
        "        move_candidate_x = 4\n",
        "        pos_after_x= src + np.array([-1,0])\n",
        "    else:\n",
        "        move_candidate_x = 0\n",
        "        pos_after_x = src \n",
        "    if dy > 0:\n",
        "        move_candidate_y = 3\n",
        "        pos_after_y = src + np.array([0,1])\n",
        "    elif dy < 0:\n",
        "        move_candidate_y = 1\n",
        "        pos_after_y = src + np.array([0,-1])\n",
        "    else:\n",
        "        move_candidate_y = 0\n",
        "        pos_after_y = src\n",
        "    \n",
        "    move_candidates = []\n",
        "    pos_after_x = (pos_after_x[0], pos_after_x[1])\n",
        "    pos_after_y = (pos_after_y[0], pos_after_y[1])\n",
        "    rejected_moves=-1\n",
        "    if pos_after_x not in opp_factories_map:\n",
        "        move_candidates.append(move_candidate_x)\n",
        "    else:\n",
        "        rejected_moves=move_candidate_x\n",
        "    if pos_after_y not in opp_factories_map:\n",
        "        move_candidates.append(move_candidate_y)\n",
        "    else:\n",
        "        rejected_moves=move_candidate_y\n",
        "    \n",
        "    if dx == 0 and dy == 0:\n",
        "        move = 0\n",
        "    else:\n",
        "        move_candidates = [mc for mc in move_candidates if mc != 0]\n",
        "        if len(move_candidates)>0:\n",
        "            move = np.random.choice(move_candidates)\n",
        "        else:\n",
        "            if rejected_moves in [1,3]:\n",
        "                for i in [1,-1,2,-2,3,-3]:\n",
        "                    pos_after_move = src + np.array([i, move_dict_vert[rejected_moves]])\n",
        "                    pos_after_move = (pos_after_move[0], pos_after_move[1])\n",
        "                    if (pos_after_move not in opp_factories_map) and pos_after_move[0]>=0 and pos_after_move[1]>=0:\n",
        "                        move_dir = np.sign(i)\n",
        "                        move_times = abs(i)\n",
        "                        move = [move_signs_hor[move_dir]]*move_times + [rejected_moves]\n",
        "                        break\n",
        "            elif rejected_moves in [2,4]:\n",
        "                for i in [1,-1,2,-2,3,-3]:\n",
        "                    pos_after_move = src + np.array([move_dict_hor[rejected_moves],i])\n",
        "                    pos_after_move = (pos_after_move[0], pos_after_move[1])\n",
        "                    if (pos_after_move not in opp_factories_map) and 0<=pos_after_move[0]<=47 and 0<=pos_after_move[1]<=47:\n",
        "                        move_dir = np.sign(i)\n",
        "                        move_times = abs(i)\n",
        "                        move = [move_signs_vert[move_dir]]*move_times + [rejected_moves]\n",
        "                        break\n",
        "    return move\n",
        "\n",
        "def simple_manh_distance(src, target):\n",
        "    ds=src-target\n",
        "    return abs(ds[0])+abs(ds[1])\n",
        "\n",
        "def square3x3(pos):\n",
        "    f_x, f_y = pos[0], pos[1]\n",
        "    map3x3 = []\n",
        "    for x in range(f_x-1,f_x+2):\n",
        "        for y in range(f_y-1,f_y+2):\n",
        "            map3x3.append(np.array([x,y]))\n",
        "    return map3x3\n",
        "\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",
        "        self.my_robots_move_queue = {}\n",
        "        self.my_robots_parent_factory = {}\n",
        "        self.hunting_dict = {}\n",
        "        self.opp_robots = {}\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",
        "            \n",
        "                valid_spawn_locations = obs[\"board\"][\"valid_spawns_mask\"]\n",
        "                ice = obs[\"board\"][\"ice\"]\n",
        "                dist_ice = manhattan_distance(1-ice)\n",
        "                start_map = valid_spawn_locations*(dist_ice.max()-dist_ice)\n",
        "                start_loc_candidates = np.argwhere(start_map==start_map.max())\n",
        "#                 spawn_loc = start_loc_candidates[np.random.randint(0, len(start_loc_candidates))]\n",
        "                \n",
        "                rubble = obs[\"board\"][\"rubble\"]\n",
        "                spawn_candidate_scores = {}\n",
        "                for i, spawn_loc_candidate in enumerate(start_loc_candidates):\n",
        "                    sp_x, sp_y = spawn_loc_candidate\n",
        "                    rub_range = 2\n",
        "                    close_rubble_map = rubble[sp_x-rub_range:sp_x+rub_range+1, sp_y-rub_range:sp_y+rub_range+1]\n",
        "                    score = (close_rubble_map==0).mean()\n",
        "                    spawn_candidate_scores[i]=score\n",
        "\n",
        "                key_of_best_candidate = max(spawn_candidate_scores, key=spawn_candidate_scores.get)\n",
        "                spawn_loc =start_loc_candidates[key_of_best_candidate]\n",
        "                return dict(spawn=spawn_loc, metal=150, water=150)\n",
        "\n",
        "            return dict()\n",
        "\n",
        "    def act(self, step: int, obs, remainingOverageTime: int = 60):\n",
        "        #print(self.player, step)\n",
        "        actions = dict()\n",
        "        game_state = obs_to_game_state(step, self.env_cfg, obs)\n",
        "        factories = game_state.factories[self.player]\n",
        "        opp_factories = game_state.factories[self.opp_player]\n",
        "        opp_factories_map = []\n",
        "        for unit_id, factory in opp_factories.items():\n",
        "            f_x, f_y = factory.pos\n",
        "            for x in range(f_x-1,f_x+2):\n",
        "                for y in range(f_y-1,f_y+2):\n",
        "                    opp_factories_map.append((x,y))\n",
        "        game_state.teams[self.player].place_first\n",
        "        factory_tiles, factory_units = [], []\n",
        "        #\n",
        "        for unit_id, unit in game_state.units[self.opp_player].items():\n",
        "            if unit_id not in self.opp_robots.keys():\n",
        "                self.opp_robots[unit_id] = {'pos': 0, 'sit_counter':0, 'target': False, 'alive': True, 'type': ''}  \n",
        "            prev_pos = self.opp_robots[unit_id]['pos']\n",
        "            cur_pos = unit.pos\n",
        "            if (prev_pos==cur_pos).mean()==1:\n",
        "                self.opp_robots[unit_id]['sit_counter']+=1\n",
        "            else:\n",
        "                self.opp_robots[unit_id]['sit_counter']=0\n",
        "            \n",
        "            if self.opp_robots[unit_id]['sit_counter'] >= 3:\n",
        "                self.opp_robots[unit_id]['target'] = True\n",
        "            self.opp_robots[unit_id]['pos'] = cur_pos\n",
        "            self.opp_robots[unit_id]['type'] = unit.unit_type\n",
        "\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 < 200) and (factory.cargo.water > 50):\n",
        "                if factory.water_cost(game_state) <= factory.cargo.water:\n",
        "                    actions[unit_id] = factory.water()\n",
        "            factory_tiles+=square3x3(factory.pos) \n",
        "            factory_units += [factory]\n",
        "        factory_tiles = np.array(factory_tiles)\n",
        "\n",
        "        units = game_state.units[self.player]\n",
        "        for u_id, u in units.items():\n",
        "            if u_id not in self.my_robots_parent_factory.keys():\n",
        "                self.my_robots_parent_factory[u_id] = square3x3(u.pos)\n",
        "\n",
        "        regular_units = {key:value for (key,value) in units.items() if key not in self.hunting_dict.keys()}\n",
        "        ice_map = game_state.board.ice\n",
        "        ice_tile_locations = np.argwhere(ice_map == 1)\n",
        "        for unit_id, unit in regular_units.items():\n",
        "            #basic stats\n",
        "            battery_capacity = 150 if unit.unit_type == \"LIGHT\" else 3000\n",
        "            # track the closest factory\n",
        "            closest_factory = None\n",
        "            adjacent_to_factory = False\n",
        "            if len(factory_tiles) > 0:\n",
        "                factory_tiles = self.my_robots_parent_factory[unit_id]\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.power < battery_capacity*0.1) & adjacent_to_factory:\n",
        "                    actions[unit_id] = [unit.pickup(4, battery_capacity-unit.power)]\n",
        "                elif unit.cargo.ice < 80:\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=1, n=1)]\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=1)]\n",
        "                # else if we have enough ice, we go back to the factory and dump it.\n",
        "                elif unit.cargo.ice >= 80:\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=1)]\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=1)]\n",
        "        #targets\n",
        "        if True:\n",
        "#         if self.player == 'player_1':\n",
        "            clean_list_h = []\n",
        "            clean_list_t = []            \n",
        "            for h,t in self.hunting_dict.items():\n",
        "                if t not in game_state.units[self.opp_player].keys():\n",
        "                    clean_list_h.append(h)\n",
        "                    clean_list_t.append(t)\n",
        "            for t in clean_list_t:\n",
        "                try:\n",
        "                    self.opp_robots.pop(t)\n",
        "                except:\n",
        "                    print('DEBUG - unhandled error')\n",
        "            for h in clean_list_h:\n",
        "                self.hunting_dict.pop(h)\n",
        "            def simple_manh_distance(src, target):\n",
        "                ds=src-target\n",
        "                return abs(ds[0])+abs(ds[1])\n",
        "            \n",
        "            hunting_pair_candidates = []\n",
        "            for opp_unit_id, opp_unit in self.opp_robots.items():\n",
        "                min_dist_to_target = 100\n",
        "                closest_unit_id = ''\n",
        "                for unit_id, unit in units.items():\n",
        "                    if (opp_unit['target'] == True) and (opp_unit['type'] == 'HEAVY') and (unit_id not in self.hunting_dict.keys()) and (opp_unit_id not in self.hunting_dict.values()):\n",
        "                        distance = simple_manh_distance(unit.pos, opp_unit['pos'])\n",
        "                        if distance < min_dist_to_target:\n",
        "                            min_dist_to_target = distance\n",
        "                            closest_unit_id = unit_id\n",
        "                if min_dist_to_target<=15 and (units[closest_unit_id].power > 2000) :\n",
        "                    hunting_pair_candidates.append({'opp_unit_id':opp_unit_id,'unit_id': closest_unit_id, 'distance': min_dist_to_target})\n",
        "            \n",
        "            if len(hunting_pair_candidates)>0:\n",
        "                hunting_pair_candidates = pd.DataFrame(hunting_pair_candidates).sort_values('distance').drop_duplicates('unit_id', keep='first')\n",
        "                for i, row in hunting_pair_candidates.iterrows():\n",
        "                    self.hunting_dict[row['unit_id']]= row['opp_unit_id']\n",
        "                    break\n",
        "                \n",
        "            dead_hunters=[]\n",
        "            for hunter,target in self.hunting_dict.items():\n",
        "                if hunter not in units.keys():\n",
        "                    dead_hunters.append(hunter)\n",
        "\n",
        "            for dh in dead_hunters:\n",
        "                try:\n",
        "                    self.hunting_dict.pop(dh)\n",
        "                except:\n",
        "                    pass\n",
        "            for hunter,target in self.hunting_dict.items():        \n",
        "                hunter_unit = units[hunter]\n",
        "                direction = direction_to_mod_2(hunter_unit.pos, self.opp_robots[target]['pos'], opp_factories_map, step, 1000)\n",
        "                if (type(direction) == list) and hunter not in self.my_robots_move_queue.keys():\n",
        "                    self.my_robots_move_queue[hunter]=direction\n",
        "                if hunter in self.my_robots_move_queue.keys():\n",
        "                    direction = self.my_robots_move_queue[hunter][0]\n",
        "                    move_cost = unit.move_cost(game_state, direction)\n",
        "                    if move_cost is not None and hunter_unit.power >= move_cost + unit.action_queue_cost(game_state):\n",
        "                        actions[hunter] = [hunter_unit.move(direction, repeat=0, n=1)]\n",
        "                        self.my_robots_move_queue[hunter]=self.my_robots_move_queue[hunter][1:]\n",
        "                        if len(self.my_robots_move_queue[hunter])==0:\n",
        "                            self.my_robots_move_queue.pop(hunter)\n",
        "                else:\n",
        "                    move_cost = unit.move_cost(game_state, direction)\n",
        "                    if move_cost is not None and hunter_unit.power >= move_cost + unit.action_queue_cost(game_state):\n",
        "                        actions[hunter] = [hunter_unit.move(direction, repeat=0, n=1)]\n",
        "                        #print('ah', actions[hunter])\n",
        "        actions_before_coord = []\n",
        "        for unit_id, unit in units.items():\n",
        "            cur_pos = unit.pos\n",
        "            if unit_id in actions.keys():\n",
        "                cur_action = actions[unit_id]\n",
        "                action_type = cur_action[0][0]\n",
        "                if action_type == 0:\n",
        "                    action_dir = cur_action[0][1]\n",
        "                    pos_after = cur_pos + move_arrays[action_dir]                    \n",
        "                else:\n",
        "                    pos_after = cur_pos\n",
        "            else:\n",
        "                action_type = 99\n",
        "                pos_after = cur_pos\n",
        "            actions_before_coord.append({'unit_id':unit_id, 'action_type': action_type, 'pos_after':str(pos_after)})\n",
        "        if len(actions_before_coord)>0:\n",
        "            actions_before_coord = pd.DataFrame(actions_before_coord)\n",
        "            actions_before_coord_wo_dupl = actions_before_coord.sort_values('action_type').drop_duplicates('pos_after', keep = 'last') \n",
        "            robots_to_wait = set(actions_before_coord['unit_id'].unique()).difference(actions_before_coord_wo_dupl['unit_id'].unique())\n",
        "            for unit_id in robots_to_wait:\n",
        "                actions.pop(unit_id)\n",
        "        return actions"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "292610ad",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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": null,
      "id": "12273ca6",
      "metadata": {
        "execution": {
          "iopub.execute_input": "2023-04-19T21:34:36.057772Z",
          "iopub.status.busy": "2023-04-19T21:34:36.057282Z",
          "iopub.status.idle": "2023-04-19T21:34:37.175866Z",
          "shell.execute_reply": "2023-04-19T21:34:37.174288Z",
          "shell.execute_reply.started": "2023-04-19T21:34:36.057726Z"
        },
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "!tar -czf submission_S01.tar.gz *"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "6718c9f8",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "#!tar -czf submission_unitcargo_wyborstartu_border_rubble_recharge_water750_50_bid2.tar.gz *"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4e4e1943",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "## Experiments"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "60815bc8",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "def interact(env, agents, steps, sd):\n",
        "    # reset our env\n",
        "    obs = env.reset(sd)\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": "code",
      "execution_count": null,
      "id": "8b2f2969",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# direction (0 = center, 1 = up, 2 = right, 3 = down, 4 = left)\n",
        "def direction_to_mod(src, target, step, step_thr = 20):\n",
        "    ds = target - src\n",
        "    dx = ds[0]\n",
        "    dy = ds[1]\n",
        "    if step > step_thr:\n",
        "        print('target pos', target) \n",
        "        print('src pos', src)\n",
        "        print('ds dy', dx, dy) \n",
        "\n",
        "    if dx == 0 and dy == 0:\n",
        "        if step > step_thr:\n",
        "            print('move center')\n",
        "        return 0\n",
        "    if abs(dx) > abs(dy):\n",
        "        if dx > 0:\n",
        "            if step > step_thr:\n",
        "                print('move right')\n",
        "            return 2 \n",
        "        else:\n",
        "            if step > step_thr:\n",
        "                print('move left')\n",
        "            return 4\n",
        "    else:\n",
        "        if dy > 0:\n",
        "            if step > step_thr:\n",
        "                print('move down')\n",
        "            return 3\n",
        "        else:\n",
        "            if step > step_thr:\n",
        "                print('move up')\n",
        "            return 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "059cf485",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# direction (0 = center, 1 = up, 2 = right, 3 = down, 4 = left)\n",
        "move_arrays = {1: np.array([0, -1]), 2: np.array([1, 0]), 3: np.array([0, 1]), 4: np.array([-1, 0])}\n",
        "def direction_to_mod_2(src, target, opp_factories_map, step, step_thr = 20):\n",
        "    move_signs_hor = {1: 2, -1: 4}\n",
        "    move_signs_vert = {1: 3, -1: 1}\n",
        "\n",
        "    move_dict_vert = {1:-1, 3:1}\n",
        "    move_dict_hor = {2:1, 4:-1}\n",
        "    ds = target - src\n",
        "    dx = ds[0]\n",
        "    dy = ds[1]\n",
        " \n",
        "    if dx == 0 and dy == 0:\n",
        "        move_candidate = 0\n",
        "        pos_after = src\n",
        "    if dx > 0:\n",
        "        move_candidate_x = 2\n",
        "        pos_after_x = src + np.array([1,0])\n",
        "    elif dx < 0:\n",
        "        move_candidate_x = 4\n",
        "        pos_after_x= src + np.array([-1,0])\n",
        "    else:\n",
        "        move_candidate_x = 0\n",
        "        pos_after_x = src \n",
        "    if dy > 0:\n",
        "        move_candidate_y = 3\n",
        "        pos_after_y = src + np.array([0,1])\n",
        "    elif dy < 0:\n",
        "        move_candidate_y = 1\n",
        "        pos_after_y = src + np.array([0,-1])\n",
        "    else:\n",
        "        move_candidate_y = 0\n",
        "        pos_after_y = src\n",
        "    \n",
        "    move_candidates = []\n",
        "    pos_after_x = (pos_after_x[0], pos_after_x[1])\n",
        "    pos_after_y = (pos_after_y[0], pos_after_y[1])\n",
        "    rejected_moves=-1\n",
        "    if pos_after_x not in opp_factories_map:\n",
        "        move_candidates.append(move_candidate_x)\n",
        "    else:\n",
        "        rejected_moves=move_candidate_x\n",
        "    if pos_after_y not in opp_factories_map:\n",
        "        move_candidates.append(move_candidate_y)\n",
        "    else:\n",
        "        rejected_moves=move_candidate_y\n",
        "    \n",
        "    if dx == 0 and dy == 0:\n",
        "        move = 0\n",
        "    else:\n",
        "        move_candidates = [mc for mc in move_candidates if mc != 0]\n",
        "        if len(move_candidates)>0:\n",
        "            move = np.random.choice(move_candidates)\n",
        "        else:\n",
        "            if rejected_moves in [1,3]:\n",
        "                for i in [1,-1,2,-2,3,-3]:\n",
        "                    pos_after_move = src + np.array([i, move_dict_vert[rejected_moves]])\n",
        "                    pos_after_move = (pos_after_move[0], pos_after_move[1])\n",
        "                    if (pos_after_move not in opp_factories_map) and pos_after_move[0]>=0 and pos_after_move[1]>=0:\n",
        "                        move_dir = np.sign(i)\n",
        "                        move_times = abs(i)\n",
        "                        move = [move_signs_hor[move_dir]]*move_times + [rejected_moves]\n",
        "                        break\n",
        "            elif rejected_moves in [2,4]:\n",
        "                for i in [1,-1,2,-2,3,-3]:\n",
        "                    pos_after_move = src + np.array([move_dict_hor[rejected_moves],i])\n",
        "                    pos_after_move = (pos_after_move[0], pos_after_move[1])\n",
        "                    if (pos_after_move not in opp_factories_map) and 0<=pos_after_move[0]<=47 and 0<=pos_after_move[1]<=47:\n",
        "                        move_dir = np.sign(i)\n",
        "                        move_times = abs(i)\n",
        "                        move = [move_signs_vert[move_dir]]*move_times + [rejected_moves]\n",
        "                        break\n",
        "    return move"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f24c4462",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "#move arrays"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cf74a8ec",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "def square3x3(pos):\n",
        "    f_x, f_y = pos[0], pos[1]\n",
        "    map3x3 = []\n",
        "    for x in range(f_x-1,f_x+2):\n",
        "        for y in range(f_y-1,f_y+2):\n",
        "            map3x3.append(np.array([x,y]))\n",
        "    return map3x3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a99d1363",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "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",
        "        self.my_robots_move_queue = {}\n",
        "        self.my_robots_parent_factory = {}\n",
        "        self.hunting_dict = {}\n",
        "        self.opp_robots = {}\n",
        "        \n",
        "        self.water_start_turn = 250\n",
        "        self.batteryStart = 0.1\n",
        "        self.\n",
        "       \n",
        "    def square3x3(pos):\n",
        "        f_x, f_y = pos[0], pos[1]\n",
        "        map3x3 = []\n",
        "        for x in range(f_x-1,f_x+2):\n",
        "            for y in range(f_y-1,f_y+2):\n",
        "                map3x3.append(np.array([x,y]))\n",
        "        return map3x3\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",
        "            \n",
        "                valid_spawn_locations = obs[\"board\"][\"valid_spawns_mask\"]\n",
        "                ice = obs[\"board\"][\"ice\"]\n",
        "                dist_ice = manhattan_distance(1-ice)\n",
        "                start_map = valid_spawn_locations*(dist_ice.max()-dist_ice)\n",
        "                start_loc_candidates = np.argwhere(start_map==start_map.max())\n",
        "#                 spawn_loc = start_loc_candidates[np.random.randint(0, len(start_loc_candidates))]\n",
        "                \n",
        "                rubble = obs[\"board\"][\"rubble\"]\n",
        "                spawn_candidate_scores = {}\n",
        "                for i, spawn_loc_candidate in enumerate(start_loc_candidates):\n",
        "                    sp_x, sp_y = spawn_loc_candidate\n",
        "                    rub_range = 2\n",
        "                    close_rubble_map = rubble[sp_x-rub_range:sp_x+rub_range+1, sp_y-rub_range:sp_y+rub_range+1]\n",
        "                    score = (close_rubble_map==0).mean()\n",
        "                    spawn_candidate_scores[i]=score\n",
        "\n",
        "                key_of_best_candidate = max(spawn_candidate_scores, key=spawn_candidate_scores.get)\n",
        "                spawn_loc =start_loc_candidates[key_of_best_candidate]\n",
        "                return dict(spawn=spawn_loc, metal=150, water=150)\n",
        "\n",
        "            return dict()\n",
        "\n",
        "    def act(self, step: int, obs, remainingOverageTime: int = 60):\n",
        "        #print(self.player, step)\n",
        "        actions = dict()\n",
        "        game_state = obs_to_game_state(step, self.env_cfg, obs)\n",
        "        factories = game_state.factories[self.player]\n",
        "        opp_factories = game_state.factories[self.opp_player]\n",
        "        opp_factories_map = []\n",
        "        for unit_id, factory in opp_factories.items():\n",
        "            f_x, f_y = factory.pos\n",
        "            for x in range(f_x-1,f_x+2):\n",
        "                for y in range(f_y-1,f_y+2):\n",
        "                    opp_factories_map.append((x,y))\n",
        "        game_state.teams[self.player].place_first\n",
        "        factory_tiles, factory_units = [], []\n",
        "        #\n",
        "        for unit_id, unit in game_state.units[self.opp_player].items():\n",
        "            if unit_id not in self.opp_robots.keys():\n",
        "                self.opp_robots[unit_id] = {'pos': 0, 'sit_counter':0, 'target': False, 'alive': True, 'type': ''}  \n",
        "            prev_pos = self.opp_robots[unit_id]['pos']\n",
        "            cur_pos = unit.pos\n",
        "            if (prev_pos==cur_pos).mean()==1:\n",
        "                self.opp_robots[unit_id]['sit_counter']+=1\n",
        "            else:\n",
        "                self.opp_robots[unit_id]['sit_counter']=0\n",
        "            \n",
        "            if self.opp_robots[unit_id]['sit_counter'] >= 3:\n",
        "                self.opp_robots[unit_id]['target'] = True\n",
        "            self.opp_robots[unit_id]['pos'] = cur_pos\n",
        "            self.opp_robots[unit_id]['type'] = unit.unit_type\n",
        "\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",
        "                \n",
        "                \n",
        "                \n",
        "            if (self.env_cfg.max_episode_length - game_state.real_env_steps < water_start_turn) and (factory.cargo.water > 50):\n",
        "                if factory.water_cost(game_state) <= factory.cargo.water:\n",
        "                    \n",
        "                    actions[unit_id] = factory.water()\n",
        "            factory_tiles+=square3x3(factory.pos) \n",
        "            factory_units += [factory]\n",
        "        factory_tiles = np.array(factory_tiles)\n",
        "\n",
        "        units = game_state.units[self.player]\n",
        "        for u_id, u in units.items():\n",
        "            if u_id not in self.my_robots_parent_factory.keys():\n",
        "                self.my_robots_parent_factory[u_id] = square3x3(u.pos)\n",
        "\n",
        "        regular_units = {key:value for (key,value) in units.items() if key not in self.hunting_dict.keys()}\n",
        "        ice_map = game_state.board.ice\n",
        "        ice_tile_locations = np.argwhere(ice_map == 1)\n",
        "        for unit_id, unit in regular_units.items():\n",
        "            #basic stats\n",
        "            battery_capacity = 150 if unit.unit_type == \"LIGHT\" else 3000\n",
        "            # track the closest factory\n",
        "            closest_factory = None\n",
        "            adjacent_to_factory = False\n",
        "            if len(factory_tiles) > 0:\n",
        "                factory_tiles = self.my_robots_parent_factory[unit_id]\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.power < battery_capacity*batteryStart) & adjacent_to_factory:\n",
        "                    actions[unit_id] = [unit.pickup(4, battery_capacity-unit.power)]\n",
        "                elif unit.cargo.ice < 150:\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=1, n=1)]\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=1)]\n",
        "                # else if we have enough ice, we go back to the factory and dump it.\n",
        "                elif unit.cargo.ice >= 150:\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=1)]\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=1)]\n",
        "        #targets\n",
        "#         if True:\n",
        "        if self.player == 'player_1':\n",
        "            clean_list_h = []\n",
        "            clean_list_t = []            \n",
        "            for h,t in self.hunting_dict.items():\n",
        "                if t not in game_state.units[self.opp_player].keys():\n",
        "                    clean_list_h.append(h)\n",
        "                    clean_list_t.append(t)\n",
        "            for t in clean_list_t:\n",
        "                try:\n",
        "                    self.opp_robots.pop(t)\n",
        "                except:\n",
        "                    print('DEBUG - unhandled error')\n",
        "            for h in clean_list_h:\n",
        "                self.hunting_dict.pop(h)\n",
        "            def simple_manh_distance(src, target):\n",
        "                ds=src-target\n",
        "                return abs(ds[0])+abs(ds[1])\n",
        "            \n",
        "            hunting_pair_candidates = []\n",
        "            for opp_unit_id, opp_unit in self.opp_robots.items():\n",
        "                min_dist_to_target = 100\n",
        "                closest_unit_id = ''\n",
        "                for unit_id, unit in units.items():\n",
        "                    if (opp_unit['target'] == True) and (opp_unit['type'] == 'HEAVY') and (unit.power == 3000) and (unit_id not in self.hunting_dict.keys()) and (opp_unit_id not in self.hunting_dict.values()):\n",
        "                        distance = simple_manh_distance(unit.pos, opp_unit['pos'])\n",
        "                        if distance < min_dist_to_target:\n",
        "                            min_dist_to_target = distance\n",
        "                            closest_unit_id = unit_id\n",
        "                if min_dist_to_target<=10:\n",
        "                    hunting_pair_candidates.append({'opp_unit_id':opp_unit_id,'unit_id': closest_unit_id, 'distance': min_dist_to_target})\n",
        "            \n",
        "            if len(hunting_pair_candidates)>0:\n",
        "                hunting_pair_candidates = pd.DataFrame(hunting_pair_candidates).sort_values('distance').drop_duplicates('unit_id', keep='first')\n",
        "                for i, row in hunting_pair_candidates.iterrows():\n",
        "                    self.hunting_dict[row['unit_id']]= row['opp_unit_id']\n",
        "                    break\n",
        "                \n",
        "            dead_hunters=[]\n",
        "            for hunter,target in self.hunting_dict.items():\n",
        "                if hunter not in units.keys():\n",
        "                    dead_hunters.append(hunter)\n",
        "\n",
        "            for dh in dead_hunters:\n",
        "                try:\n",
        "                    self.hunting_dict.pop(dh)\n",
        "                except:\n",
        "                    pass\n",
        "            for hunter,target in self.hunting_dict.items():        \n",
        "                hunter_unit = units[hunter]\n",
        "                direction = direction_to_mod_2(hunter_unit.pos, self.opp_robots[target]['pos'], opp_factories_map, step, 1000)\n",
        "                if (type(direction) == list) and hunter not in self.my_robots_move_queue.keys():\n",
        "                    self.my_robots_move_queue[hunter]=direction\n",
        "                if hunter in self.my_robots_move_queue.keys():\n",
        "                    direction = self.my_robots_move_queue[hunter][0]\n",
        "                    move_cost = unit.move_cost(game_state, direction)\n",
        "                    if move_cost is not None and hunter_unit.power >= move_cost + unit.action_queue_cost(game_state):\n",
        "                        actions[hunter] = [hunter_unit.move(direction, repeat=0, n=1)]\n",
        "                        self.my_robots_move_queue[hunter]=self.my_robots_move_queue[hunter][1:]\n",
        "                        if len(self.my_robots_move_queue[hunter])==0:\n",
        "                            self.my_robots_move_queue.pop(hunter)\n",
        "                else:\n",
        "                    move_cost = unit.move_cost(game_state, direction)\n",
        "                    if move_cost is not None and hunter_unit.power >= move_cost + unit.action_queue_cost(game_state):\n",
        "                        actions[hunter] = [hunter_unit.move(direction, repeat=0, n=1)]\n",
        "                        #print('ah', actions[hunter])\n",
        "        actions_before_coord = []\n",
        "        for unit_id, unit in units.items():\n",
        "            cur_pos = unit.pos\n",
        "            if unit_id in actions.keys():\n",
        "                cur_action = actions[unit_id]\n",
        "                action_type = cur_action[0][0]\n",
        "                if action_type == 0:\n",
        "                    action_dir = cur_action[0][1]\n",
        "                    pos_after = cur_pos + move_arrays[action_dir]                    \n",
        "                else:\n",
        "                    pos_after = cur_pos\n",
        "            else:\n",
        "                action_type = 99\n",
        "                pos_after = cur_pos\n",
        "            actions_before_coord.append({'unit_id':unit_id, 'action_type': action_type, 'pos_after':str(pos_after)})\n",
        "        if len(actions_before_coord)>0:\n",
        "            actions_before_coord = pd.DataFrame(actions_before_coord)\n",
        "            actions_before_coord_wo_dupl = actions_before_coord.sort_values('action_type').drop_duplicates('pos_after', keep = 'last') \n",
        "            robots_to_wait = set(actions_before_coord['unit_id'].unique()).difference(actions_before_coord_wo_dupl['unit_id'].unique())\n",
        "            for unit_id in robots_to_wait:\n",
        "                actions.pop(unit_id)\n",
        "        return actions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "f3e30a19",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "sd = 18"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e65f23d5",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "env_2 = gym.make(\"LuxAI_S2-v0\")\n",
        "env_2.reset(seed=sd)\n",
        "img = env_2.render(\"rgb_array\")\n",
        "plt.imshow(img)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e426948d",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# recreate our agents and run\n",
        "agents = {player: Agent(player, env_2.state.env_cfg) for player in env_2.agents}\n",
        "interact(env, agents, 500, sd)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0f1c8fa5",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "game_state = obs_to_game_state(25, env.state.env_cfg, env.observation_space('player_1'))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dff51bb5",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "game_state = obs_to_game_state(20, env.state.env_cfg, env)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "aa5be378",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "# Praca domowa 20.02.2023\n",
        "# Zmodyfikowac co najmniej 1 parametr bota a nastepnie wyslac jako rozwiazanie do konkursu i obserwowac wyniki bota\n",
        "# Nazwy zespolow musza zawierac ciag znakow \"KNAI_\""
      ]
    },
    {
      "cell_type": "markdown",
      "id": "9eb645a3",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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-2022-beta/ 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",
      "id": "5f265f15",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "# Praca domowa 2023-02-06\n",
        "Zmodyfikowac jeden parametr zgodnie z intuicja i wyslac na leaderboard"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "e3417054",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "# Tematy ogolne\n",
        "- Struktura zawodow w KNAI -> zawody wewnetrzne oraz ogolne\n",
        "- Gdzie zaczyna sie sztuczna inteligencja?\n",
        "- Wywiad z Samem Altmanem, Prezesem OPEN AI, ktore stworzylo Chat GPT 3 https://www.forbes.com/sites/alexkonrad/2023/02/03/exclusive-openai-sam-altman-chatgpt-agi-google-search/?sh=cb2b78d6a633\n",
        "- Nauka parametrow vs nauka mety gry. \n",
        "- Imitation learning. \n",
        "- Ukrywanie dobrych botow. \n",
        "- Sprint prizes"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "48464d97",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "source": [
        "## CLI Tool\n",
        "\n",
        "To test your agent without using the python API you can also run"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bf75eed7",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "!luxai-s2 main.py main.py -v 2 -s 101 -o replay.html"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "22185f69",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "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,
      "id": "b90f0a9d",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": [
        "import IPython # load the HTML replay\n",
        "IPython.display.HTML(filename='replay.html')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e553b57f",
      "metadata": {
        "papermill": {
          "duration": null,
          "end_time": null,
          "exception": null,
          "start_time": null,
          "status": "pending"
        },
        "tags": []
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kaggle": {
      "accelerator": "none",
      "dataSources": [
        {
          "databundleVersionId": 5062922,
          "sourceId": 45040,
          "sourceType": "competition"
        }
      ],
      "dockerImageVersionId": 30380,
      "isGpuEnabled": false,
      "isInternetEnabled": true,
      "language": "python",
      "sourceType": "notebook"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.12"
    },
    "papermill": {
      "default_parameters": {},
      "duration": null,
      "end_time": null,
      "environment_variables": {},
      "exception": null,
      "input_path": "__notebook__.ipynb",
      "output_path": "__notebook__.ipynb",
      "parameters": {},
      "start_time": "2024-03-03T21:35:26.218290",
      "version": "2.3.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}