{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8979120e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "from matplotlib.patches import PathPatch\n",
    "from matplotlib.path import Path\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# This class creates a 8x8 board with a temperature field,\n",
    "# normalized to have values roughly of the order of -5 to +5,\n",
    "# changing over time due to the motion of heat sources which have\n",
    "# a short-ranged influence on the temperature.\n",
    "#\n",
    "# An agent is moving over the board; the aim of the agent is to avoid extreme\n",
    "# temperature zones in order to stay alive. (For that, see the Agent class below.)\n",
    "#\n",
    "class Surroundings:\n",
    "    grid_size = 8  # 8x8 grid like a chessboard\n",
    "    radius_of_sight = 2  # the agent can see two fields in each direction\n",
    "    \n",
    "    _num_heat_sources = 8  # how many heat sources there are on the board\n",
    "    _v_square_per_source = 0.25  # mean square velocity of the heat sources\n",
    "    \n",
    "    _base_temperature = -5    # temperature in the absence of a heat source\n",
    "    _influence_radius =  2.5  # radius within which an influence of the heat source is perceived\n",
    "    _temperature_scale = 2.5  # maximum temperature increase due to a single heat source\n",
    "    \n",
    "    \n",
    "    def __init__(self):\n",
    "        self._debug_output = False\n",
    "        self._temperature = np.zeros((Surroundings.grid_size, Surroundings.grid_size))\n",
    "        acceptable_starting_configuration = False\n",
    "        while not acceptable_starting_configuration:\n",
    "            self._heat_source_position = [(random.uniform(0, Surroundings.grid_size), \\\n",
    "                                           random.uniform(0, Surroundings.grid_size)) \\\n",
    "                                          for i in range(Surroundings._num_heat_sources)]\n",
    "            self._compute_temperature()\n",
    "            self._agent_position = [random.randrange(1, Surroundings.grid_size - 1), \\\n",
    "                                    random.randrange(1, Surroundings.grid_size - 1)]\n",
    "            T_start = self._temperature[self._agent_position[0], self._agent_position[1]]\n",
    "            if T_start > -0.2* Surroundings._temperature_scale \\\n",
    "            and T_start < 0.2* Surroundings._temperature_scale:\n",
    "                acceptable_starting_configuration = True\n",
    "        self._heat_source_velocity = [(0, 0) for i in range(Surroundings._num_heat_sources)]\n",
    "        for i in range(Surroundings._num_heat_sources):\n",
    "            vi0 = random.uniform(0, Surroundings._v_square_per_source)**0.5\n",
    "            if random.randrange(2) == 1:\n",
    "                vi0 = -vi0\n",
    "            vi1 = random.uniform(0, Surroundings._v_square_per_source)**0.5\n",
    "            if random.randrange(2) == 1:\n",
    "                vi1 = -vi1\n",
    "            self._heat_source_velocity[i] = (vi0, vi1)\n",
    "    \n",
    "    def _compute_temperature(self):\n",
    "        for x0 in range(Surroundings.grid_size):\n",
    "            for x1 in range(Surroundings.grid_size):\n",
    "                self._temperature[x0, x1] = Surroundings._base_temperature\n",
    "                for (q0, q1) in self._heat_source_position:\n",
    "                    distance = ((x0 - q0)**2 + (x1 - q1)**2)**0.5  # distance to heat source\n",
    "                    if distance < Surroundings._influence_radius:  # add temperature contribution\n",
    "                        self._temperature[x0][x1] += Surroundings._temperature_scale \\\n",
    "                        * (Surroundings._influence_radius - distance)\n",
    "    \n",
    "    def _move_heat_sources(self):\n",
    "        for i in range(Surroundings._num_heat_sources):\n",
    "            (qi0, qi1) = self._heat_source_position[i]\n",
    "            (vi0, vi1) = self._heat_source_velocity[i]\n",
    "            qi0 += vi0\n",
    "            if qi0 < 0:  # hard-wall boundary condition in x0 direction\n",
    "                qi0 = -qi0\n",
    "                vi0 = -vi0\n",
    "            if qi0 > Surroundings.grid_size:\n",
    "                qi0 = 2*Surroundings.grid_size - qi0\n",
    "                vi0 = -vi0\n",
    "            qi1 += vi1\n",
    "            if qi1 < 0:  # hard-wall boundary condition in x1 direction\n",
    "                qi1 = -qi1\n",
    "                vi1 = -vi1\n",
    "            if qi1 > Surroundings.grid_size:\n",
    "                qi1 = 2*Surroundings.grid_size - qi1\n",
    "                vi1 = -vi1\n",
    "            self._heat_source_position[i] = (qi0, qi1)\n",
    "            self._heat_source_velocity[i] = (vi0, vi1)\n",
    "        self._compute_temperature()\n",
    "        if self._debug_output:\n",
    "            print(\"Agent at:\", self._agent_position, end=\"\\t\\t\")\n",
    "            print(\"Local temperature:\", \\\n",
    "                  round(self._temperature[self._agent_position[0], self._agent_position[1]], 2))\n",
    "    \n",
    "    def activate_debug_output(self):\n",
    "        self._debug_output = True\n",
    "    \n",
    "    def visualize(self):\n",
    "        fig, ax = plt.subplots()\n",
    "        fig.set_size_inches(7, 7)\n",
    "        plt.xticks(fontsize=18, color=\"#322300\")\n",
    "        plt.yticks(fontsize=18, color=\"#322300\")\n",
    "        ax.set_xlabel(\"coordinate x1\", fontsize=24, color=\"#322300\")\n",
    "        ax.set_ylabel(\"coordinate x0\", fontsize=24, color=\"#322300\")\n",
    "        im = plt.imshow(self._temperature, extent=[-0.5, Surroundings.grid_size-0.5, \\\n",
    "                                              Surroundings.grid_size-0.5, -0.5])\n",
    "        cb = plt.colorbar()\n",
    "        q0 = self._agent_position[0]\n",
    "        q1 = self._agent_position[1]\n",
    "        path = Path([[q1, q0+0.5], [q1+0.5, q0], [q1, q0-0.5], [q1-0.5, q0], [q1, q0+0.5]])\n",
    "        patch = PathPatch(path, facecolor='#ff0000')\n",
    "        ax.add_patch(patch)\n",
    "    \n",
    "    def perceive_local_temperature(self):\n",
    "        return self._temperature[self._agent_position[0], self._agent_position[1]]\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) at the position with x0 increased by one, and 1) with x0 increased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x0_higher(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0] + i + 1\n",
    "            q1 = self._agent_position[1]\n",
    "            if q0 < Surroundings.grid_size:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) at the position with x0 decreased by one, and 1) with x0 decreased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x0_lower(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0] - i - 1\n",
    "            q1 = self._agent_position[1]\n",
    "            if q0 >= 0:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) at the position with x1 increased by one, and 1) with x1 increased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x1_higher(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0]\n",
    "            q1 = self._agent_position[1] + i + 1\n",
    "            if q1 < Surroundings.grid_size:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # returns a percept list consisting of the temperature value\n",
    "    # 0) the position with x1 decreased by one, and 1) with x1 decreased by 2\n",
    "    #\n",
    "    # if we are at the edge of the board, infinity is returned as the temperature value\n",
    "    #\n",
    "    def perceive_temperature_x1_lower(self):\n",
    "        percept = []\n",
    "        for i in range(Surroundings.radius_of_sight):\n",
    "            q0 = self._agent_position[0]\n",
    "            q1 = self._agent_position[1] - i - 1\n",
    "            if q1 >= 0:\n",
    "                percept.append(self._temperature[q0, q1])\n",
    "            else:\n",
    "                percept.append(math.inf)\n",
    "        return percept\n",
    "    \n",
    "    # agent decides to increase x0 by one\n",
    "    #\n",
    "    def action_increment_x0(self):\n",
    "        if self._agent_position[0] < Surroundings.grid_size - 1:\n",
    "            self._agent_position[0] += 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_increment_x0 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to decrease x0 by one\n",
    "    #\n",
    "    def action_decrement_x0(self):\n",
    "        if self._agent_position[0] > 0:\n",
    "            self._agent_position[0] -= 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_decrement_x0 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to increase x1 by one\n",
    "    #\n",
    "    def action_increment_x1(self):\n",
    "        if self._agent_position[1] < Surroundings.grid_size - 1:\n",
    "            self._agent_position[1] += 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_increment_x1 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to decrease x1 by one\n",
    "    #\n",
    "    def action_decrement_x1(self):\n",
    "        if self._agent_position[1] > 0:\n",
    "            self._agent_position[1] -= 1\n",
    "        else:\n",
    "            print(\"\\tWarning: action_decrement_x1 at\", self._agent_position, \"failed due to wall\")\n",
    "        self._move_heat_sources()\n",
    "    \n",
    "    # agent decides to sit around and do nothing\n",
    "    #\n",
    "    def action_wait(self):\n",
    "        self._move_heat_sources()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d4a9db14",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "landscape = Surroundings()\n",
    "landscape.visualize()\n",
    "for i in range(1):\n",
    "    landscape._move_heat_sources()\n",
    "landscape.visualize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f5cc57d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Agent:\n",
    "    temperature_tolerance = 4  # if temperature is outside the range from -4 to +4, the agent dies\n",
    "    \n",
    "    def __init__(self, landscape):\n",
    "        self._alive = True\n",
    "        self._environment = landscape\n",
    "        self._timestep = 0\n",
    "    \n",
    "    # gather percepts\n",
    "    #\n",
    "    def sensor_input(self):\n",
    "        self._local_temperature = self._environment.perceive_local_temperature()\n",
    "        self._percept_x0_higher = self._environment.perceive_temperature_x0_higher()\n",
    "        self._percept_x0_lower = self._environment.perceive_temperature_x0_lower()\n",
    "        self._percept_x1_higher = self._environment.perceive_temperature_x1_higher()\n",
    "        self._percept_x1_lower = self._environment.perceive_temperature_x1_lower()\n",
    "        \n",
    "        # check whether the agent dies due to extreme temperature\n",
    "        #\n",
    "        if abs(self._local_temperature) > Agent.temperature_tolerance:\n",
    "            self._alive = False\n",
    "    \n",
    "    # keep gathering percepts and calling the agent function until, eventually, the agent dies\n",
    "    #\n",
    "    # the function returns the number of timesteps that it takes until the agent dies\n",
    "    #\n",
    "    def live(self):\n",
    "        self.sensor_input()\n",
    "        while self._alive:\n",
    "            self._timestep += 1\n",
    "            self.agent_function()\n",
    "            self.sensor_input()\n",
    "        # print(\"Agent died after\", self._timestep, \"steps\")\n",
    "        return self._timestep\n",
    "            \n",
    "    \n",
    "### ****** ONLY THE FUNCTION BELOW SHOULD BE MODIFIED TO IMPROVE THE AGENT'S BEHAVIOUR ****** ### \n",
    "    \n",
    "    # a very basic and straightforward agent function by\n",
    "    # which the agent wanders around the landscape, trying to\n",
    "    # avoid zones with extreme temperatures\n",
    "    #\n",
    "    def agent_function(self):\n",
    "        \n",
    "        # remark:\n",
    "        #\n",
    "        # the agent function would be allowed to store percepts so that\n",
    "        # they can be remembered in the future, etc.; this simple solution\n",
    "        # does not do that, it only relies on the present percepts\n",
    "        \n",
    "        # look for a direction that decreases abs(temperature) and walk there\n",
    "        #\n",
    "        # we are using the percept for the temperature two fields away in each direction,\n",
    "        # e.g., _percept_x0_higher[1] corresponds to the field with x0 increased by 2\n",
    "        #\n",
    "        if abs(self._percept_x0_higher[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_increment_x0()\n",
    "        elif abs(self._percept_x0_lower[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_decrement_x0()\n",
    "        elif abs(self._percept_x1_higher[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_increment_x1()\n",
    "        elif abs(self._percept_x1_lower[1]) < abs(self._local_temperature):\n",
    "            self._environment.action_decrement_x1()\n",
    "        else:\n",
    "            self._environment.action_wait()\n",
    "    \n",
    "### ****** ONLY THE FUNCTION ABOVE SHOULD BE MODIFIED TO IMPROVE THE AGENT'S BEHAVIOUR ****** ### "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bea35d8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent at: [1, 5]\t\tLocal temperature: -1.98\n",
      "Agent at: [2, 5]\t\tLocal temperature: -4.41\n",
      "\n",
      "****\n",
      "The agent died after 2 steps\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "landscape = Surroundings()\n",
    "landscape.activate_debug_output()\n",
    "landscape.visualize()\n",
    "\n",
    "agent = Agent(landscape)\n",
    "time = agent.live()\n",
    "print(\"\\n****\\nThe agent died after\", time, \"steps\")\n",
    "\n",
    "landscape.visualize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4fe2a05c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t6\t6.0\n",
      "100\t19\t19.228\n",
      "200\t25\t18.289\n",
      "300\t14\t18.628\n",
      "400\t18\t18.908\n",
      "500\t43\t18.729\n",
      "600\t7\t18.541\n",
      "700\t15\t18.465\n",
      "800\t10\t18.557\n",
      "900\t83\t18.541\n",
      "1000\t27\t18.273\n",
      "1100\t5\t18.215\n",
      "1200\t16\t18.439\n",
      "1300\t18\t18.336\n",
      "1400\t6\t18.275\n",
      "1500\t26\t18.185\n",
      "1600\t6\t18.066\n",
      "1700\t22\t18.049\n",
      "1800\t7\t18.052\n",
      "1900\t8\t18.12\n",
      "2000\t40\t18.065\n",
      "2100\t14\t18.212\n",
      "2200\t50\t18.129\n",
      "2300\t13\t18.173\n",
      "2400\t9\t18.176\n",
      "2500\t7\t18.242\n",
      "2600\t15\t18.302\n",
      "2700\t10\t18.348\n",
      "2800\t19\t18.34\n",
      "2900\t13\t18.387\n",
      "3000\t18\t18.373\n",
      "3100\t7\t18.325\n",
      "3200\t19\t18.358\n",
      "3300\t22\t18.371\n",
      "3400\t25\t18.338\n",
      "3500\t8\t18.256\n",
      "3600\t12\t18.251\n",
      "3700\t28\t18.313\n",
      "3800\t11\t18.329\n",
      "3900\t28\t18.309\n",
      "4000\t4\t18.328\n",
      "4100\t18\t18.359\n",
      "4200\t16\t18.394\n",
      "4300\t27\t18.384\n",
      "4400\t54\t18.419\n",
      "4500\t25\t18.361\n",
      "4600\t12\t18.456\n",
      "4700\t5\t18.445\n",
      "4800\t28\t18.379\n",
      "4900\t17\t18.356\n",
      "****\n",
      "Average life: 18.333 steps\n"
     ]
    }
   ],
   "source": [
    "repetitions = 5000\n",
    "\n",
    "total_life = 0\n",
    "for i in range(repetitions):\n",
    "    landscape = Surroundings()\n",
    "    agent = Agent(landscape)\n",
    "    this_life = agent.live()\n",
    "    total_life += this_life\n",
    "    if i%100 == 0:\n",
    "        print(i, this_life, round(total_life/(i+1), 3), sep=\"\\t\")\n",
    "\n",
    "print(\"****\\nAverage life:\", round(total_life/repetitions, 3), \"steps\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb26f404",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}