Homework 8/domaci8.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "domaci8.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO7J1aq9jGeIA/gURwuzJ8p",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/NikolaZubic/AppliedGameTheoryHomeworkSolutions/blob/main/domaci8.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_tXwFZw-7awj"
      },
      "source": [
        "# OSMI DOMAĆI ZADATAK iz predmeta \"Primenjena teorija igara\" (Applied Game Theory)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rXMj5VO67e_6"
      },
      "source": [
        "a) Simulacija diferencijalne igre sa N letjelica koristeći prioritet<br>\n",
        "b) Simulacija diferencijalne igre sa N letjelica koristeći funkciju nesreće"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RZhkrQk99-ZO"
      },
      "source": [
        "Implementirano po uzoru na [link](https://github.com/aalu1418/differential-games)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fN6yAcTb7vXq"
      },
      "source": [
        "# Potrebni import-i i konstante"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BSeL6cnc7xAd"
      },
      "source": [
        "from math import sqrt\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# CONSTANTS\n",
        "DISTANCE_COLLISION = 20  # a)\n",
        "DETECTION_RADIUS = 140   # b)\n",
        "\n",
        "COLOURS = ['b', 'g', 'r', 'c', 'm', 'y', 'k']  # to represent aircrafts on plot\n",
        "###########"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AU7aAqki8Pqq"
      },
      "source": [
        "# Definisanje klase koja enkapsulira osnovne informacije o svakom agentu (letjelici) u ovoj diferencijalnoj igri"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "99ccVPJj8V2i"
      },
      "source": [
        "class AgentInfo(object):\n",
        "    \"\"\"\n",
        "    Encapsulates main information about every agent regarding its goal, initial position, history of taken positions\n",
        "    during the differential game, maximum velocity and id.\n",
        "    \"\"\"\n",
        "    def __init__(self, goal, initial_position, maximum_velocity, identifier):\n",
        "        self.goal = goal\n",
        "        self.initial_position = initial_position\n",
        "        # after assigning initial position, make it as position_0 in position's history\n",
        "        self.positions_history = [self.initial_position]\n",
        "        self.maximum_velocity = maximum_velocity\n",
        "        self.identifier = identifier"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENSIQYNL8ZhS"
      },
      "source": [
        "# Definisanje agenta za a)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aerVGkCt8bFS"
      },
      "source": [
        "class SimpleAgent(object):\n",
        "    def __init__(self, agent_info):\n",
        "        self.agent_info = agent_info\n",
        "\n",
        "    @property\n",
        "    def get_current_position(self):\n",
        "        return self.agent_info.positions_history[-1]  # get the last element in collection\n",
        "\n",
        "    @property\n",
        "    def get_aircraft_index(self):\n",
        "        return self.agent_info.identifier\n",
        "\n",
        "    def collision_region_detected(self, j, collision_distance):\n",
        "        \"\"\"\n",
        "        :param j: other aircraft\n",
        "        :param collision_distance: d_c\n",
        "        :return: whether we have detected another aircraft in collision region\n",
        "        \"\"\"\n",
        "        current_x, current_y = self.get_current_position[0], self.get_current_position[1]  # aircraft that we analyze\n",
        "        x_j, y_j = j\n",
        "\n",
        "        norm = sqrt(pow(x_j - current_x, 2) + pow(y_j - current_y, 2))\n",
        "\n",
        "        return norm < collision_distance  # inside the region, STRICTLY less\n",
        "\n",
        "    def priority_policy(self, aircrafts):\n",
        "        \"\"\"\n",
        "        We assign a priority to all aircrafts whereat the lower indexes are aircrafts of higher priorities.\n",
        "        [x0, ... , xN] means that x0 has HIGHER priority than x1, ... , x(N-1) has HIGHER priority than xN.\n",
        "\n",
        "        :param aircrafts: all aircrafts in differential game\n",
        "        :return: updated position by going with either maximum velocity or 0 in other case\n",
        "        \"\"\"\n",
        "        current_aircraft_id = self.get_aircraft_index\n",
        "\n",
        "        # take all aircrafts that have HIGHER priority than the current one (that we analyze)\n",
        "        for i in range(0, current_aircraft_id):\n",
        "            if self.collision_region_detected(aircrafts[i].get_current_position, DISTANCE_COLLISION):\n",
        "                # If an agent is in the collision region with an aircraft of higher priority, don't move him\n",
        "                return None\n",
        "\n",
        "        current_x, current_y = self.get_current_position[0], self.get_current_position[1]\n",
        "        goal_x, goal_y = self.agent_info.goal[0], self.agent_info.goal[1]\n",
        "\n",
        "        distance_from_goal_x, distance_from_goal_y = goal_x - current_x, goal_y - current_y\n",
        "        norm = sqrt(pow(distance_from_goal_x, 2) + pow(distance_from_goal_y, 2))\n",
        "\n",
        "        if norm != 0:\n",
        "            move_vector_x, move_vector_y = distance_from_goal_x / norm, distance_from_goal_y / norm\n",
        "        else:\n",
        "            move_vector_x, move_vector_y = 0, 0\n",
        "\n",
        "        # take all aircrafts that have LOWER priority than the current one (that we analyze)\n",
        "        for i in range(current_aircraft_id + 1, len(aircrafts)):\n",
        "            \"\"\"\n",
        "            If an agent is in the collision region with an aircraft of lower priority, then it is expected that he 'll\n",
        "            move with maximum velocity and the aircraft with lower priority won't move.\n",
        "            \"\"\"\n",
        "            if self.collision_region_detected(aircrafts[i].get_current_position, DISTANCE_COLLISION):\n",
        "                update_position_x = current_x + self.agent_info.maximum_velocity * move_vector_x\n",
        "                update_position_y = current_y + self.agent_info.maximum_velocity * move_vector_y\n",
        "\n",
        "                return update_position_x, update_position_y\n",
        "\n",
        "        update_x = current_x + self.agent_info.maximum_velocity * move_vector_x\n",
        "        update_y = current_y + self.agent_info.maximum_velocity * move_vector_y\n",
        "\n",
        "        return update_x, update_y\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "irTx4vBF8eGz"
      },
      "source": [
        "# Definisanje unaprijeđenog agenta za b)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AHO-t_xe8f2k"
      },
      "source": [
        "class ImprovedAgent(object):\n",
        "    def __init__(self, agent_info):\n",
        "        self.agent_info = agent_info\n",
        "\n",
        "    @property\n",
        "    def get_current_position(self):\n",
        "        return self.agent_info.positions_history[-1]  # get the last element in collection\n",
        "\n",
        "    @property\n",
        "    def get_aircraft_index(self):\n",
        "        return self.agent_info.identifier\n",
        "\n",
        "    def collision_region_detected(self, j, collision_distance):\n",
        "        \"\"\"\n",
        "        :param j: other aircraft\n",
        "        :param collision_distance: d_c\n",
        "        :return: whether we have detected another aircraft in collision region\n",
        "        \"\"\"\n",
        "        current_x, current_y = self.get_current_position[0], self.get_current_position[1]  # aircraft that we analyze\n",
        "        x_j, y_j = j\n",
        "\n",
        "        norm = sqrt(pow(x_j - current_x, 2) + pow(y_j - current_y, 2))\n",
        "\n",
        "        return norm < collision_distance  # inside the region, STRICTLY less\n",
        "\n",
        "    def degree_of_accident_policy(self, aircrafts):\n",
        "        \"\"\"\n",
        "        Here, we implement new policy where we have some detection radius R for each aircraft. Additionally, we use\n",
        "        function called degree of accident V that is defined as following for i-th aircraft:\n",
        "        V_i(x_1, x_2, ... , x_N) = (1/2) * (||x_i - z_i||)^2 + (1/2) *\n",
        "        sum[for j != i]( max( (R^2 - ||x_i - x_j||^2) / (||x_i - x_j||^2 - r^2) , 0) )^2 ,\n",
        "\n",
        "        where x_i is current position of i-th aircraft, x_j is current position of j-th aircraft in j-th iteration\n",
        "        through sum, z_i is the goal of i-th aircraft.\n",
        "\n",
        "        This helps us to detect collision region between aircrafts only if they are inside detection radius, otherwise\n",
        "        we won't take them into account. Maximum function inside sum will produce big number if aircrafts are INSIDE\n",
        "        (strictly less) collision region, which will lead to upsurge of V.\n",
        "\n",
        "        :param aircrafts: all aircrafts in differential game\n",
        "        :return: updated position based on V function\n",
        "        \"\"\"\n",
        "\n",
        "        # v_i = z_i - x_i + sum[j]( a_ij * (x_i - x_j) )\n",
        "\n",
        "        a_i, a_j = 0, 0\n",
        "        current_x, current_y = self.get_current_position[0], self.get_current_position[1]\n",
        "\n",
        "        for aircraft in aircrafts:\n",
        "            if aircraft.get_aircraft_index != self.get_aircraft_index:\n",
        "                # analyze all the other aircrafts from the viewpoint of current aircraft\n",
        "                x_j, y_j = aircraft.get_current_position[0], aircraft.get_current_position[1]\n",
        "\n",
        "                distance_ij_X, distance_ij_Y = x_j - current_x, y_j - current_y\n",
        "\n",
        "                norm = sqrt(pow(distance_ij_X, 2) + pow(distance_ij_Y, 2))\n",
        "\n",
        "                # max( (R^2 - ||x_i - x_j||^2) / (||x_i - x_j||^2 - r^2) , 0)\n",
        "                max_function = max(\n",
        "                    (pow(DETECTION_RADIUS, 2) - pow(norm, 2)) / (pow(norm, 2) - pow(DISTANCE_COLLISION, 2)), 0)\n",
        "\n",
        "                a_i, a_j = a_i + distance_ij_X * max_function, a_j + distance_ij_Y * max_function\n",
        "\n",
        "        goal_x, goal_y = self.agent_info.goal[0], self.agent_info.goal[1]\n",
        "\n",
        "        distance_from_goal_x, distance_from_goal_y = goal_x - current_x, goal_y - current_y\n",
        "\n",
        "        z_minus_x_i, z_minus_x_j = distance_from_goal_x - a_i, distance_from_goal_y - a_j\n",
        "        norm = sqrt(pow(z_minus_x_i, 2) + pow(z_minus_x_j, 2))\n",
        "\n",
        "        move_vector_x, move_vector_y = z_minus_x_i / norm, z_minus_x_j / norm\n",
        "\n",
        "        update_x = current_x + self.agent_info.maximum_velocity * move_vector_x\n",
        "        update_y = current_y + self.agent_info.maximum_velocity * move_vector_y\n",
        "\n",
        "        return update_x, update_y\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CxX0iKQH8kU7"
      },
      "source": [
        "# Definisanje klase zadužene za simulaciju"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPNc24158lJ7"
      },
      "source": [
        "class Simulation(object):\n",
        "    def __init__(self, aircrafts):\n",
        "        self.aircrafts = aircrafts\n",
        "\n",
        "    def run(self):\n",
        "        for i in range(200):\n",
        "            for aircraft in self.aircrafts:\n",
        "                if isinstance(aircraft, SimpleAgent):\n",
        "                    position = aircraft.priority_policy(aircrafts=aircrafts)\n",
        "\n",
        "                    if position is not None:\n",
        "                        aircraft.agent_info.positions_history.append(position)\n",
        "\n",
        "                elif isinstance(aircraft, ImprovedAgent):\n",
        "                    position = aircraft.degree_of_accident_policy(aircrafts=aircrafts)\n",
        "\n",
        "                    if position is not None:\n",
        "                        aircraft.agent_info.positions_history.append(position)\n",
        "\n",
        "    def draw(self):\n",
        "        plt.xlim(-205, 205)\n",
        "        plt.ylim(-155, 155)\n",
        "        plt.xlabel('x', fontsize=18)\n",
        "        plt.ylabel('y', fontsize=18)\n",
        "\n",
        "        i = 0\n",
        "\n",
        "        for aircraft in self.aircrafts:\n",
        "            x, y = [], []\n",
        "            for position in aircraft.agent_info.positions_history:\n",
        "                x.append(position[0])\n",
        "                y.append(position[1])\n",
        "\n",
        "            plt.plot(x, y, \"{}\".format(COLOURS[i]), linestyle=\"dotted\")\n",
        "\n",
        "            plt.plot(aircraft.agent_info.initial_position[0], aircraft.agent_info.initial_position[1],\n",
        "                     \"{}o\".format(COLOURS[i]), markersize=9)\n",
        "\n",
        "            plt.plot(aircraft.agent_info.goal[0], aircraft.agent_info.goal[1],\n",
        "                     \"{}x\".format(COLOURS[i]), markersize=9)\n",
        "\n",
        "            i += 1\n",
        "\n",
        "        plt.show()\n",
        "\n",
        "    @staticmethod\n",
        "    def run_simulation(agents):\n",
        "        simulation = Simulation(agents)\n",
        "        simulation.run()\n",
        "        simulation.draw()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qZkeGMPR8pok"
      },
      "source": [
        "# Glavni program (pokretanje simulacije)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 881
        },
        "id": "3aVGVFlF8rJ9",
        "outputId": "df06a4dc-e5bf-4ea3-9c25-3da0643f63d0"
      },
      "source": [
        "if __name__ == \"__main__\":\n",
        "    aircrafts_info = [\n",
        "        AgentInfo(goal=(200, 100), initial_position=(-200, -100), maximum_velocity=40, identifier=0),\n",
        "        AgentInfo(goal=(-100, 80), initial_position=(-160, -45), maximum_velocity=20, identifier=1),\n",
        "        AgentInfo(goal=(200, -100), initial_position=(-200, 100), maximum_velocity=30, identifier=2),\n",
        "        AgentInfo(goal=(0, 0), initial_position=(-195, 25), maximum_velocity=35, identifier=3),\n",
        "        AgentInfo(goal=(0, -75), initial_position=(0, 75), maximum_velocity=25, identifier=4),\n",
        "        AgentInfo(goal=(0, 75), initial_position=(0, -75), maximum_velocity=25, identifier=5),\n",
        "    ]\n",
        "\n",
        "    aircrafts = [SimpleAgent(aircrafts_info[i]) for i in range(len(aircrafts_info) - 2)]\n",
        "    improved_aircrafts = [ImprovedAgent(aircrafts_info[i]) for i in range(len(aircrafts_info))]\n",
        "\n",
        "    print(\"Running simulation a)\")\n",
        "    Simulation.run_simulation(aircrafts)\n",
        "    print(\"Running simulation b)\")\n",
        "    Simulation.run_simulation(improved_aircrafts)\n",
        "\n",
        "    aircrafts_info = [\n",
        "        AgentInfo(goal=(80, 80), initial_position=(-80, -80), maximum_velocity=25, identifier=0),\n",
        "        AgentInfo(goal=(-80, 80), initial_position=(80, -80), maximum_velocity=40, identifier=1)\n",
        "    ]\n",
        "    improved_aircrafts = [ImprovedAgent(aircrafts_info[i]) for i in range(len(aircrafts_info))]\n",
        "    print(\"Running simulation b) #2\")\n",
        "    Simulation.run_simulation(improved_aircrafts)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Running simulation a)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Running simulation b)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Running simulation b) #2\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}