i200762_Section_B_Assig_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2a6ec878",
   "metadata": {},
   "source": [
    "# Assignment #3: Genetic Algorithm (Training Cars with GA)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c78e4fd8",
   "metadata": {},
   "source": [
    "### Required Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57dd98a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install pygame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e69c557e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.5.2 (SDL 2.28.3, Python 3.11.3)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
     ]
    }
   ],
   "source": [
    "import pygame\n",
    "import time\n",
    "import math\n",
    "import random\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a36514cc",
   "metadata": {},
   "source": [
    "### Helping functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c5adf261",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_image(img, factor):\n",
    "    size = round(img.get_width() * factor), round(img.get_height() * factor)\n",
    "    return pygame.transform.scale(img, size)\n",
    "\n",
    "def blit_rotate_center(win, image, top_left, angle):\n",
    "    rotated_image = pygame.transform.rotate(image, angle)\n",
    "    new_rect = rotated_image.get_rect(\n",
    "        center=image.get_rect(topleft=top_left).center)\n",
    "    win.blit(rotated_image, new_rect.topleft)\n",
    "    \n",
    "def blit_text_center(win, font, text):\n",
    "    render = font.render(text, 1, (200, 200, 200))\n",
    "    win.blit(render, (win.get_width()/2 - render.get_width() /\n",
    "                      2, win.get_height()/2 - render.get_height()/2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3327d70c",
   "metadata": {},
   "source": [
    "### Abstract Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3f61c856",
   "metadata": {},
   "outputs": [],
   "source": [
    "class GameInfo:\n",
    "    LEVELS = 1\n",
    "\n",
    "    def __init__(self, level=1):\n",
    "        self.level = level\n",
    "        self.started = False\n",
    "        self.level_start_time = 0\n",
    "\n",
    "    def next_level(self):\n",
    "        self.level += 1\n",
    "        self.started = False\n",
    "\n",
    "    def reset(self):\n",
    "        self.level = 1\n",
    "        self.started = False\n",
    "        self.level_start_time = 0\n",
    "\n",
    "    def game_finished(self):\n",
    "        return self.level > self.LEVELS\n",
    "\n",
    "    def start_level(self):\n",
    "        self.started = True\n",
    "        self.level_start_time = time.time()\n",
    "\n",
    "    def get_level_time(self):\n",
    "        if not self.started:\n",
    "            return 0\n",
    "        return round(time.time() - self.level_start_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78c945ee",
   "metadata": {},
   "source": [
    "### Sensor Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3ac123dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SensorBullet:\n",
    "    def __init__(self, car, base_angle, vel, color):\n",
    "        self.x = car.x + CAR_WIDTH/2\n",
    "        self.y = car.y + CAR_HEIGHT/2\n",
    "        self.angle = car.angle\n",
    "        self.base_angle = base_angle\n",
    "        self.vel = vel\n",
    "        self.color = color\n",
    "        self.img = pygame.Surface((4, 4))\n",
    "        self.fired = False\n",
    "        self.hit = False\n",
    "        self.last_poi = None\n",
    "\n",
    "    def draw(self, win):\n",
    "        pygame.draw.circle(win, self.color, (self.x, self.y), 2)\n",
    "\n",
    "    def fire(self, car):\n",
    "        self.angle = car.angle + self.base_angle\n",
    "        self.x = car.x + CAR_WIDTH/2\n",
    "        self.y = car.y + CAR_HEIGHT/2\n",
    "        self.fired = True\n",
    "        self.hit = False\n",
    "\n",
    "    def move(self):\n",
    "        if(self.fired):\n",
    "            radians = math.radians(self.angle)\n",
    "            vertical = math.cos(radians) * self.vel\n",
    "            horizontal = math.sin(radians) * self.vel\n",
    "\n",
    "            self.y -= vertical\n",
    "            self.x -= horizontal\n",
    "\n",
    "    def collide(self, x=0, y=0):\n",
    "        bullet_mask = pygame.mask.from_surface(self.img)\n",
    "        offset = (int(self.x - x), int(self.y - y))\n",
    "        poi = TRACK_BORDER_MASK.overlap(bullet_mask, offset)\n",
    "        if poi:\n",
    "            self.fired = False\n",
    "            self.hit = True\n",
    "            self.last_poi = poi\n",
    "        return poi\n",
    "\n",
    "    def draw_line(self, win, car):\n",
    "        if self.hit:\n",
    "            pygame.draw.line(win, self.color, (car.x + CAR_WIDTH/2, car.y + CAR_HEIGHT/2), (self.x, self.y), 1)\n",
    "            pygame.display.update()\n",
    "\n",
    "    def get_distance_from_poi(self, car):\n",
    "        if self.last_poi is None:\n",
    "            return -1\n",
    "        return math.sqrt((car.x - self.last_poi[0])**2 + (car.y - self.last_poi[1])**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e05a448f",
   "metadata": {},
   "source": [
    "### Drawing and Collision functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c97c9750",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw(win, images, cars, level_time, checkpoints, n_cars, generation, most_checkpoints, max_for_this_gen):\n",
    "        \n",
    "    for img, pos in images:\n",
    "        win.blit(img, pos)\n",
    "        \n",
    "    for checkpoint in checkpoints:\n",
    "        win.blit(checkpoint['image'], checkpoint['position'])\n",
    "        \n",
    "    win.blit(TRACK_BORDER, (0, 0))\n",
    "\n",
    "\n",
    "    time_text = MAIN_FONT.render(\n",
    "        f\"Time: {level_time}s\", 1, (255, 255, 0))\n",
    "    win.blit(time_text, (10, HEIGHT - time_text.get_height() - 40))\n",
    "    \n",
    "    c_text = MAIN_FONT.render(\n",
    "        f\"No. of Cars: {n_cars}\", 1, (255, 255, 0))\n",
    "    win.blit(c_text, (10, HEIGHT - time_text.get_height() - 80))\n",
    "    \n",
    "    g_text = MAIN_FONT.render(\n",
    "        f\"Generation: {generation}\", 1, (255, 255, 0))\n",
    "    win.blit(g_text, (10, HEIGHT - time_text.get_height() - 120))\n",
    "    \n",
    "    m_text = MAIN_FONT.render(\n",
    "        f\"Max Checkpoints: {most_checkpoints}\", 1, (255, 255, 0))\n",
    "    win.blit(m_text, (10, HEIGHT - time_text.get_height() - 160))\n",
    "    \n",
    "    l_text = MAIN_FONT.render(\n",
    "        f\"Max for this generation: {max_for_this_gen}\", 1, (255, 255, 0))\n",
    "    win.blit(l_text, (10, HEIGHT - time_text.get_height() - 200))\n",
    "\n",
    "\n",
    "\n",
    "    for car in cars:\n",
    "        if car.active:\n",
    "            car.draw(win)\n",
    "            for bullet in car.sensors:\n",
    "                bullet.draw(win)\n",
    "        \n",
    "\n",
    "    pygame.display.update()\n",
    "\n",
    "\n",
    "def handle_collision(car, checkpoints:list(),FINISH_MASK):\n",
    "    if car.collide(TRACK_BORDER_MASK) != None:\n",
    "        car.bounce()\n",
    "        car.active = False\n",
    "\n",
    "    for bullet in car.sensors:\n",
    "        if bullet.collide() != None:\n",
    "            bullet.draw_line(WIN, car)\n",
    "\n",
    "    player_finish_poi_collide = car.collide(\n",
    "        FINISH_MASK, *FINISH_POSITION)\n",
    "    if player_finish_poi_collide != None:\n",
    "        if player_finish_poi_collide[1] == 0:\n",
    "            car.bounce()\n",
    "            car.score -= 0.01\n",
    "            car.active = False\n",
    "        else:\n",
    "            car.completed = True\n",
    "            return True\n",
    "            \n",
    "    idx = car.checkpoints\n",
    "    if idx < 30:\n",
    "        player_checkpoint_collide = car.collide(checkpoints[idx]['mask'], *checkpoints[idx]['position'])\n",
    "        if player_checkpoint_collide != None:\n",
    "            car.checkpoints += 1\n",
    "            car.score += 1\n",
    "            car.time = game_info.get_level_time()\n",
    "    else:\n",
    "        car.completed = True\n",
    "        return True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5ebe80f",
   "metadata": {},
   "source": [
    "### Abstract Car Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4cc3362c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbstractCar:\n",
    "    def __init__(self):\n",
    "        self.img = self.IMG\n",
    "        self.vel = 0\n",
    "        self.angle = 0\n",
    "        self.x, self.y = self.START_POS\n",
    "\n",
    "    def draw(self, win):\n",
    "        blit_rotate_center(win, self.img, (self.x, self.y), self.angle)\n",
    "        \n",
    "    def collide(self, mask, x=0, y=0):\n",
    "        car_mask = pygame.mask.from_surface(self.img)\n",
    "        offset = (int(self.x - x), int(self.y - y))\n",
    "        poi = mask.overlap(car_mask, offset)\n",
    "        return poi\n",
    "\n",
    "    def action(self,direction, acceleration):\n",
    "        if direction == 1:\n",
    "            self.vel = acceleration\n",
    "        elif direction == 2:\n",
    "            self.vel = -acceleration / 2\n",
    "        elif direction == 3:\n",
    "            self.angle += -acceleration\n",
    "        elif direction == 4:\n",
    "            self.angle += acceleration\n",
    "            \n",
    "        self.move()\n",
    "\n",
    "    def move(self):\n",
    "        radians = math.radians(self.angle)\n",
    "        vertical = math.cos(radians) * self.vel\n",
    "        horizontal = math.sin(radians) * self.vel \n",
    "\n",
    "        self.y -= vertical\n",
    "        self.x -= horizontal\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d35de4",
   "metadata": {},
   "source": [
    "### Window Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "76a19239",
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.font.init()\n",
    "\n",
    "WIDTH, HEIGHT = 800,800\n",
    "WIN = pygame.display.set_mode((WIDTH, HEIGHT))\n",
    "pygame.display.set_caption(\"Genetic Algorithm on cars! (Assignment #3)\")\n",
    "\n",
    "MAIN_FONT = pygame.font.SysFont(\"Times New Roman\", 44)\n",
    "\n",
    "GRASS = scale_image(pygame.image.load(\"imgs/grass.jpg\"), 2.5)\n",
    "TRACK = scale_image(pygame.image.load(\"imgs/track.png\"), 0.9)\n",
    "\n",
    "TRACK_BORDER = scale_image(pygame.image.load(\"imgs/track-border.png\"), 0.9)\n",
    "TRACK_BORDER_MASK = pygame.mask.from_surface(TRACK_BORDER)\n",
    "\n",
    "FINISH = pygame.image.load(\"imgs/finish.png\")\n",
    "\n",
    "FINISH_MASK = pygame.mask.from_surface(FINISH)\n",
    "FINISH_POSITION = (130, 250)\n",
    "\n",
    "\n",
    "RED_CAR = scale_image(pygame.image.load(\"imgs/red-car.png\"), 0.40)\n",
    "\n",
    "CAR_WIDTH, CAR_HEIGHT = RED_CAR.get_width(), RED_CAR.get_height()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2df24ac6",
   "metadata": {},
   "source": [
    "### Agent Car Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3c22f126",
   "metadata": {},
   "outputs": [],
   "source": [
    "RED_CAR = scale_image(pygame.image.load(\"imgs/red-car.png\"), 0.40)\n",
    "\n",
    "CAR_WIDTH, CAR_HEIGHT = RED_CAR.get_width(), RED_CAR.get_height()\n",
    "class AgentCar(AbstractCar):\n",
    "    IMG = RED_CAR\n",
    "    START_POS = (160, 200)\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.sensors = [SensorBullet(self, 45, 20, (0, 0, 255)), SensorBullet(self, 25, 20, (0, 0, 255)), SensorBullet(self, 0, 20, (0, 255, 0)), SensorBullet(self, -25, 20, (0, 0, 255)), SensorBullet(self, -45, 20, (0, 0, 255))]\n",
    "        self.completed = False\n",
    "        self.active = True\n",
    "        self.checkpoints = 0\n",
    "        self.score = 0\n",
    "        self.time = 0\n",
    "        self.sensor_combinations = []\n",
    "        for i in range(2**5):\n",
    "            binary_str = bin(i)[2:].zfill(5)\n",
    "            self.sensor_combinations.append([int(bit) for bit in binary_str])\n",
    "        self.chromosome = self.initailze_chromosome()\n",
    "    \n",
    "    def reduce_speed(self):\n",
    "        self.vel = max(self.vel - 0.1 / 2, 0)\n",
    "        self.move()\n",
    "\n",
    "    def bounce(self):\n",
    "        self.vel = -self.vel\n",
    "        self.move()\n",
    "\n",
    "    def fireSensors(self): \n",
    "        for bullet in self.sensors:\n",
    "            bullet.fire(self)\n",
    "    \n",
    "    def sensorControl(self):\n",
    "        #print(contains(self.sensors, lambda x: x.hit))\n",
    "\n",
    "        for bullet in self.sensors:\n",
    "            if not bullet.fired:\n",
    "                bullet.fire(self)\n",
    "\n",
    "        for bullet in self.sensors:\n",
    "            bullet.move()\n",
    "    \n",
    "    def get_distance_array(self):\n",
    "        continous = [bullet.get_distance_from_poi(self) for bullet in self.sensors]\n",
    "        discrete_distance = [1 if i <= 75 else 0 for i in continous]\n",
    "        return discrete_distance\n",
    "    \n",
    "    def reset(self):\n",
    "        self.x, self.y = self.START_POS\n",
    "        self.angle = 0\n",
    "        self.vel = 0\n",
    "        self.checkpoints = 0\n",
    "        self.score = 0\n",
    "        self.time = 0\n",
    "        self.active = True\n",
    "        \n",
    "    def reset_score(self):\n",
    "        self.score = 0\n",
    "        \n",
    "    def initailze_chromosome(self):\n",
    "        chromosomes = {}\n",
    "\n",
    "        for state in self.sensor_combinations:\n",
    "            direction = random.randint(1, 4)\n",
    "#             acc = random.randint(1, 10)\n",
    "            chromosomes[str(state)] = direction\n",
    "\n",
    "        return chromosomes\n",
    "    \n",
    "    def move_car(self):\n",
    "        input_state = self.get_distance_array()\n",
    "        \n",
    "        actions = self.chromosome[str(input_state)]\n",
    "        \n",
    "        speed = 5\n",
    "        self.action(actions, speed)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c1ac5f9",
   "metadata": {},
   "source": [
    "### Fitness, Crossover, Mutation Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a7d4aa16",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_fitness(car):\n",
    "    # Set initial fitness to a low value\n",
    "    fitness = 100  # Base value\n",
    "    checkpoint_bonus = 100 * car.checkpoints\n",
    "    time_penalty = 1 / (car.time + 1)  # Inverse of time (higher is better)\n",
    "    completion_reward = 0\n",
    "\n",
    "    # If the car has completed the track, reward completion\n",
    "    if car.completed:\n",
    "        completion_reward = 1000  # Reward for completion\n",
    "    else:\n",
    "        # Penalize cars that do not complete the track\n",
    "        fitness -= 10  # Small penalty for non-completion\n",
    "\n",
    "    fitness += completion_reward + time_penalty + checkpoint_bonus\n",
    "\n",
    "    return fitness\n",
    "\n",
    "\n",
    "# ----------------------------------------------------------------------#\n",
    "#               Your crossover and mutation functions here              #\n",
    "#-----------------------------------------------------------------------#\n",
    "\n",
    "\n",
    "def crossover(parent1, parent2):\n",
    "    child1 = {}\n",
    "    child2 = {}\n",
    "\n",
    "    # pick first half of parent1 and second half of parent2 for child 1\n",
    "    for key in parent1.keys():\n",
    "        if random.random() < 0.5:\n",
    "            child1[key] = parent1[key]\n",
    "        else:\n",
    "            child1[key] = parent2[key]\n",
    "\n",
    "    # pick first half of parent2 and second half of parent1 for child 2\n",
    "    for key in parent2.keys():\n",
    "        if random.random() < 0.5:\n",
    "            child2[key] = parent2[key]\n",
    "        else:\n",
    "            child2[key] = parent1[key]\n",
    "\n",
    "    print(\"Crossover of parents: \", parent1, \" and \", parent2, \" produced children: \", child1, \" and \", child2 , \"\\n\")\n",
    "    \n",
    "    return child1, child2\n",
    "\n",
    "\n",
    "\n",
    "def mutation(chromosome, mutationRate):\n",
    "    for key in chromosome.keys():\n",
    "        if random.random() < mutationRate:\n",
    "            chromosome[key] = random.randint(1, 4)\n",
    "    \n",
    "    return chromosome\n",
    "\n",
    "\n",
    "def select_parent(cars):\n",
    "    fitness_values = [calculate_fitness(car) for car in cars]\n",
    "    # Calculate the sum of all fitness values\n",
    "    total_fitness = sum(fitness_values)\n",
    "\n",
    "    # Generate a random value between 0 and the total fitness\n",
    "    random_value = random.uniform(0, total_fitness)\n",
    "\n",
    "    # Initialize variables to keep track of the selected car and its fitness\n",
    "    selected_car = None\n",
    "    current_fitness = 0\n",
    "\n",
    "    # Iterate through the cars and select the one that corresponds to the random value\n",
    "    for car, fitness in zip(cars, fitness_values):\n",
    "        current_fitness += fitness\n",
    "        if current_fitness >= random_value:\n",
    "            selected_car = car\n",
    "            break\n",
    "\n",
    "    return selected_car\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a3989fd",
   "metadata": {},
   "source": [
    "# Driver Code/ Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae78927a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Intialize population\n",
    "pop_size = 100\n",
    "cars  = [AgentCar() for _ in range(pop_size)]\n",
    "active_cars = pop_size\n",
    "generation = 0\n",
    "max_checkpoints = 0\n",
    "\n",
    "highest_checkpoint_num = 0\n",
    "\n",
    "\n",
    "while True:\n",
    "    active_cars = pop_size\n",
    "    pygame.font.init()\n",
    "    \n",
    "    MAIN_FONT = pygame.font.SysFont(\"Times New Roman\", 44)\n",
    "    GRASS = scale_image(pygame.image.load(\"imgs/grass.jpg\"), 2.5)\n",
    "    TRACK = scale_image(pygame.image.load(\"imgs/track.png\"), 0.9)\n",
    "    TRACK_BORDER = scale_image(pygame.image.load(\"imgs/track-border.png\"), 0.9)\n",
    "    TRACK_BORDER_MASK = pygame.mask.from_surface(TRACK_BORDER)\n",
    "    FINISH = pygame.image.load(\"imgs/finish.png\")\n",
    "    FINISH_MASK = pygame.mask.from_surface(FINISH)\n",
    "    FINISH_POSITION = (130, 250)\n",
    "    RED_CAR = scale_image(pygame.image.load(\"imgs/red-car.png\"), 0.40)\n",
    "    CAR_WIDTH, CAR_HEIGHT = RED_CAR.get_width(), RED_CAR.get_height()\n",
    "\n",
    "    checkpoint_image = pygame.image.load(\"imgs/finish.png\")\n",
    "    checks = [\n",
    "            (130, 150),(130, 60), (110,30), (30,60) ,(0,150), (0, 250) ,(0,350),(90,550),(190,650),(350,650), #default checkpoints\n",
    "            (350,550), (400, 450), (500, 430),(530, 450), (550,550), (550,650), (700,650),(700,550), (700,450),(680,350), (630,320), (630, 220), (630,30), (550,30), (450,30), (350,30),\n",
    "            (700, 150),(230, 150),(230, 250),\n",
    "            (550,320),(550,200),(655,680)\n",
    "        ]\n",
    "    checkpoints = list()\n",
    "\n",
    "    for position in checks:\n",
    "        if position in [(550,320),(550,200),(655,680),(110,30),(500, 430),(630,320) ,(630, 220),(630,30), (550,30), (450,30), (350,30)]:\n",
    "            checkpoint_mask = pygame.mask.from_surface(pygame.transform.rotate(checkpoint_image, 90))\n",
    "            checkpoints.append({\n",
    "                'image': pygame.transform.rotate(checkpoint_image, 90),\n",
    "                'mask': checkpoint_mask,\n",
    "                'position': position\n",
    "            })\n",
    "        elif position in [(130, 60),(530, 450),(680,350)]:\n",
    "            checkpoint_mask = pygame.mask.from_surface(pygame.transform.rotate(checkpoint_image, 45))\n",
    "            checkpoints.append({\n",
    "                'image': pygame.transform.rotate(checkpoint_image, 45),\n",
    "                'mask': checkpoint_mask,\n",
    "                'position': position\n",
    "            })\n",
    "\n",
    "        elif position in [(30, 60),(400, 450)]:\n",
    "            checkpoint_mask = pygame.mask.from_surface(pygame.transform.rotate(checkpoint_image, 135))\n",
    "            checkpoints.append({\n",
    "                'image': pygame.transform.rotate(checkpoint_image, 135),\n",
    "                'mask': checkpoint_mask,\n",
    "                'position': position\n",
    "            })\n",
    "        else:\n",
    "            checkpoint_mask = pygame.mask.from_surface(checkpoint_image)\n",
    "            checkpoints.append({\n",
    "                'image': checkpoint_image,\n",
    "                'mask': checkpoint_mask,\n",
    "                'position': position\n",
    "            })\n",
    "    clock = pygame.time.Clock()\n",
    "    images = [(GRASS, (0, 0)), (TRACK, (0, 0)), (FINISH, FINISH_POSITION)]\n",
    "    \n",
    "    WIDTH, HEIGHT = 800,800\n",
    "    WIN = pygame.display.set_mode((WIDTH, HEIGHT))\n",
    "    pygame.display.set_caption(\"Autonomus Car2!\")\n",
    "        \n",
    "    generation += 1\n",
    "    print(\"Generation: \", generation)\n",
    "    print(\"\\n\\n\\n\\n\")\n",
    "    game_info = GameInfo()\n",
    "    prev_parents = list()\n",
    "    prev_cum_sum = 0\n",
    "    \n",
    "    factor = 3\n",
    "    max_time = factor *  max_checkpoints + 10\n",
    "    check = False\n",
    "\n",
    "    max_for_this_gen = 0\n",
    "\n",
    "    temp_cars = cars.copy()\n",
    "    temp_cars.sort(key=calculate_fitness, reverse=True)\n",
    "\n",
    "    while game_info.get_level_time() < max_time and active_cars > 0:\n",
    "        temp_cars.sort(key=calculate_fitness, reverse=True)\n",
    "\n",
    "    #     clock.tick(FPS)\n",
    "        if game_info.started == False:\n",
    "            game_info.start_level()\n",
    "\n",
    "        max_for_this_gen = temp_cars[0].checkpoints\n",
    "        draw(WIN, images, cars, max_time - game_info.get_level_time() ,checkpoints,active_cars, generation, highest_checkpoint_num, max_for_this_gen)\n",
    "\n",
    "        for event in pygame.event.get():\n",
    "            if event.type == pygame.QUIT:\n",
    "                break\n",
    "\n",
    "        active_cars = 0\n",
    "        for car in cars:\n",
    "            if car.active and not car.completed:\n",
    "                active_cars+=1\n",
    "                car.sensorControl()\n",
    "                car.move_car()\n",
    "                check = handle_collision(car, checkpoints, FINISH_MASK)\n",
    "                highest_checkpoint_num = max(highest_checkpoint_num, car.checkpoints)\n",
    "                print(\"Car: \", cars.index(car), \"Checkpoints: \", car.checkpoints, \"Score: \", car.score, \"Fitness: \", calculate_fitness(car))\n",
    "\n",
    "            \n",
    "    \n",
    "    # ----------------------------------------------------------------------#\n",
    "    #                   Your GA code stars below this point                 #\n",
    "    #-----------------------------------------------------------------------#\n",
    "    \n",
    "    # Here are the variables you will be working with:\n",
    "    \n",
    "    # pop_size: 100\n",
    "    # # cars: which contain list of cars (all of them instances of AgentCar())\n",
    "    # cars = [AgentCar() for _ in range(pop_size)]\n",
    "    # <ANYCAR>.chromosome: chromosome of the car in the form [Sensor Values]:Movement as a dictionary\n",
    "    # <ANYCAR>.completed which upon True, will be the end goal of the GA\n",
    "    # calculate_fitness(<ANYCAR>): returns fitness value of the car, higher is better\n",
    "    \n",
    "    # Here is the general algorithm we recommend you to follow. \n",
    "    # If you want to change the algorithm a bit, feel free.\n",
    "    \n",
    "    # Sort cars list by fitness value (this is already done for you below)\n",
    "    cars.sort(key=calculate_fitness, reverse=True)\n",
    "\n",
    "    num_elite = int(0.35 * pop_size)\n",
    "    elite = cars[:num_elite]\n",
    "    new_generation = []\n",
    "    # print fitnesses of cars with the number of checkpoints reached\n",
    "\n",
    "    \n",
    "    # Check if best car is has reached all checkpoints (<ANYCAR>.completed)\n",
    "    if cars[0].completed:\n",
    "        print(\"\\n\\n\\nBest car has reached all checkpoints in \",   generation, \" generations!\\n\\n\\n\" )\n",
    "    #     if true, then just escape the loop using a break statement\n",
    "        break\n",
    "    # Iterate from 0 to half of the population value\n",
    "    for i in range(pop_size - num_elite):\n",
    "        parent1 = select_parent(cars)\n",
    "        parent2 = select_parent(cars)\n",
    "\n",
    "        \n",
    "        child1 = AgentCar()\n",
    "        child2 = AgentCar()\n",
    "\n",
    "        child1.chromosome, child2.chromosome = crossover(parent1.chromosome, parent2.chromosome)\n",
    "        \n",
    "        child1.chromosome = mutation(child1.chromosome, 0.18)\n",
    "        child2.chromosome = mutation(child2.chromosome, 0.18)\n",
    "\n",
    "        new_generation.append(child1)\n",
    "        new_generation.append(child2)\n",
    "    # Replace cars list with new generation list\n",
    "    cars = elite + new_generation\n",
    "\n",
    "    try:\n",
    "        max_checkpoints = cars[0].checkpoints\n",
    "    except IndexError:\n",
    "        max_checkpoints = 0\n",
    "    \n",
    "    # If you perform any sort of elitism or carry over old parents into the new generation, \n",
    "\n",
    "    # make sure to reset the state of each car in the old generation. \n",
    "\n",
    "    # The command for that is <ANYCAR>.reset(). This command will not return any value.\n",
    "    for car in cars:\n",
    "        car.reset()\n",
    "        \n",
    "     # Good luck!\n",
    "\n",
    "    \n",
    "    # This line of code self-adjusts the time for each generation, please do not remove it :)\n",
    "    \n",
    "\n",
    "    # clear_output()\n",
    "    \n",
    "    # Let this stay here, it will quit the game at each generation and begin a new one\n",
    "    pygame.quit()\n",
    "\n",
    "# clear_output()\n",
    "pygame.quit()    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6032710e",
   "metadata": {},
   "source": [
    "# Saving chromosomes of population which cleared 10 checkpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "89155faf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.AgentCar at 0x25a7fbb4bd0>,\n",
       " <__main__.AgentCar at 0x25a6bad1510>,\n",
       " <__main__.AgentCar at 0x25a7fbb74d0>,\n",
       " <__main__.AgentCar at 0x25a7fba8850>,\n",
       " <__main__.AgentCar at 0x25a7fba9b90>,\n",
       " <__main__.AgentCar at 0x25a7fbaae90>,\n",
       " <__main__.AgentCar at 0x25a7fbabfd0>,\n",
       " <__main__.AgentCar at 0x25a7fba55d0>,\n",
       " <__main__.AgentCar at 0x25a7fba6910>,\n",
       " <__main__.AgentCar at 0x25a7fbaaed0>,\n",
       " <__main__.AgentCar at 0x25a7fbbcf90>,\n",
       " <__main__.AgentCar at 0x25a7fbbe2d0>,\n",
       " <__main__.AgentCar at 0x25a7fbbf610>,\n",
       " <__main__.AgentCar at 0x25a7fbc0990>,\n",
       " <__main__.AgentCar at 0x25a7fbc1cd0>,\n",
       " <__main__.AgentCar at 0x25a7fbc3010>,\n",
       " <__main__.AgentCar at 0x25a7fbc3fd0>,\n",
       " <__main__.AgentCar at 0x25a7fbc96d0>,\n",
       " <__main__.AgentCar at 0x25a7fbcaa10>,\n",
       " <__main__.AgentCar at 0x25a7fbcbd50>,\n",
       " <__main__.AgentCar at 0x25a7fbcd0d0>,\n",
       " <__main__.AgentCar at 0x25a7fbce410>,\n",
       " <__main__.AgentCar at 0x25a7fbcf750>,\n",
       " <__main__.AgentCar at 0x25a7fbd0ad0>,\n",
       " <__main__.AgentCar at 0x25a7fbd1e10>,\n",
       " <__main__.AgentCar at 0x25a7fbd3150>,\n",
       " <__main__.AgentCar at 0x25a7fbd3fd0>,\n",
       " <__main__.AgentCar at 0x25a7fbd5810>,\n",
       " <__main__.AgentCar at 0x25a7fbd6b50>,\n",
       " <__main__.AgentCar at 0x25a7fbd7e90>,\n",
       " <__main__.AgentCar at 0x25a7fbd9210>,\n",
       " <__main__.AgentCar at 0x25a7fbda550>,\n",
       " <__main__.AgentCar at 0x25a7fbdb890>,\n",
       " <__main__.AgentCar at 0x25a7fbdcc10>,\n",
       " <__main__.AgentCar at 0x25a7fbddf50>,\n",
       " <__main__.AgentCar at 0x25a7fbdf290>,\n",
       " <__main__.AgentCar at 0x25a7fbdffd0>,\n",
       " <__main__.AgentCar at 0x25a7fbe1950>,\n",
       " <__main__.AgentCar at 0x25a7fbe2c90>,\n",
       " <__main__.AgentCar at 0x25a7fbe3fd0>,\n",
       " <__main__.AgentCar at 0x25a7fbe9350>,\n",
       " <__main__.AgentCar at 0x25a7fbea690>,\n",
       " <__main__.AgentCar at 0x25a7fbeb9d0>,\n",
       " <__main__.AgentCar at 0x25a7fbecd50>,\n",
       " <__main__.AgentCar at 0x25a7fbee090>,\n",
       " <__main__.AgentCar at 0x25a7fbef3d0>,\n",
       " <__main__.AgentCar at 0x25a7fbeffd0>,\n",
       " <__main__.AgentCar at 0x25a7fea1a90>,\n",
       " <__main__.AgentCar at 0x25a7fea2dd0>,\n",
       " <__main__.AgentCar at 0x25a7fea3fd0>,\n",
       " <__main__.AgentCar at 0x25a7fea9490>,\n",
       " <__main__.AgentCar at 0x25a7feaa7d0>,\n",
       " <__main__.AgentCar at 0x25a7feabb10>,\n",
       " <__main__.AgentCar at 0x25a7feace90>,\n",
       " <__main__.AgentCar at 0x25a7feae1d0>,\n",
       " <__main__.AgentCar at 0x25a7feaf510>,\n",
       " <__main__.AgentCar at 0x25a7feb0890>,\n",
       " <__main__.AgentCar at 0x25a7feb1bd0>,\n",
       " <__main__.AgentCar at 0x25a7feb2f10>,\n",
       " <__main__.AgentCar at 0x25a7feb3fd0>,\n",
       " <__main__.AgentCar at 0x25a7feb55d0>,\n",
       " <__main__.AgentCar at 0x25a7feb6910>,\n",
       " <__main__.AgentCar at 0x25a7feb7c50>,\n",
       " <__main__.AgentCar at 0x25a7feb8fd0>,\n",
       " <__main__.AgentCar at 0x25a7feba310>,\n",
       " <__main__.AgentCar at 0x25a7febb650>,\n",
       " <__main__.AgentCar at 0x25a7fec09d0>,\n",
       " <__main__.AgentCar at 0x25a7fec1d10>,\n",
       " <__main__.AgentCar at 0x25a7fec3050>,\n",
       " <__main__.AgentCar at 0x25a7fec3fd0>,\n",
       " <__main__.AgentCar at 0x25a7fec5710>,\n",
       " <__main__.AgentCar at 0x25a7fec6a50>,\n",
       " <__main__.AgentCar at 0x25a7fec7d90>,\n",
       " <__main__.AgentCar at 0x25a7fec9110>,\n",
       " <__main__.AgentCar at 0x25a7feca450>,\n",
       " <__main__.AgentCar at 0x25a7fecb790>,\n",
       " <__main__.AgentCar at 0x25a7feccb10>,\n",
       " <__main__.AgentCar at 0x25a7fecde50>,\n",
       " <__main__.AgentCar at 0x25a7fecf190>,\n",
       " <__main__.AgentCar at 0x25a7fecffd0>,\n",
       " <__main__.AgentCar at 0x25a7fed5850>,\n",
       " <__main__.AgentCar at 0x25a7fed6b90>,\n",
       " <__main__.AgentCar at 0x25a7fed7ed0>,\n",
       " <__main__.AgentCar at 0x25a7fed9250>,\n",
       " <__main__.AgentCar at 0x25a7feda590>,\n",
       " <__main__.AgentCar at 0x25a7fedb8d0>,\n",
       " <__main__.AgentCar at 0x25a7fedcc50>,\n",
       " <__main__.AgentCar at 0x25a7feddf90>,\n",
       " <__main__.AgentCar at 0x25a7fedf2d0>,\n",
       " <__main__.AgentCar at 0x25a7fedffd0>,\n",
       " <__main__.AgentCar at 0x25a7fee1990>,\n",
       " <__main__.AgentCar at 0x25a7fee2cd0>,\n",
       " <__main__.AgentCar at 0x25a7fee3fd0>,\n",
       " <__main__.AgentCar at 0x25a7fee5390>,\n",
       " <__main__.AgentCar at 0x25a7fee66d0>,\n",
       " <__main__.AgentCar at 0x25a7fee7a10>,\n",
       " <__main__.AgentCar at 0x25a7feecd90>,\n",
       " <__main__.AgentCar at 0x25a7feee0d0>,\n",
       " <__main__.AgentCar at 0x25a7feef410>,\n",
       " <__main__.AgentCar at 0x25a7feeffd0>,\n",
       " <__main__.AgentCar at 0x25a7fef5ad0>,\n",
       " <__main__.AgentCar at 0x25a7fef6e10>,\n",
       " <__main__.AgentCar at 0x25a7fef7fd0>,\n",
       " <__main__.AgentCar at 0x25a7fef94d0>,\n",
       " <__main__.AgentCar at 0x25a7fefa810>,\n",
       " <__main__.AgentCar at 0x25a7fefbb50>,\n",
       " <__main__.AgentCar at 0x25a7fefced0>,\n",
       " <__main__.AgentCar at 0x25a7fefe210>,\n",
       " <__main__.AgentCar at 0x25a7feff550>,\n",
       " <__main__.AgentCar at 0x25a7ff008d0>,\n",
       " <__main__.AgentCar at 0x25a7ff01c10>,\n",
       " <__main__.AgentCar at 0x25a7ff02f50>,\n",
       " <__main__.AgentCar at 0x25a7ff03fd0>,\n",
       " <__main__.AgentCar at 0x25a7ff05610>,\n",
       " <__main__.AgentCar at 0x25a7ff06950>,\n",
       " <__main__.AgentCar at 0x25a7ff07c90>,\n",
       " <__main__.AgentCar at 0x25a7ff09010>,\n",
       " <__main__.AgentCar at 0x25a7ff0a350>,\n",
       " <__main__.AgentCar at 0x25a7ff0b690>,\n",
       " <__main__.AgentCar at 0x25a7ff0ca10>,\n",
       " <__main__.AgentCar at 0x25a7ff0dd50>,\n",
       " <__main__.AgentCar at 0x25a7ff0f090>,\n",
       " <__main__.AgentCar at 0x25a7ff0ffd0>,\n",
       " <__main__.AgentCar at 0x25a7ff11750>,\n",
       " <__main__.AgentCar at 0x25a7ff12a90>,\n",
       " <__main__.AgentCar at 0x25a7ff13dd0>,\n",
       " <__main__.AgentCar at 0x25a7ff19150>,\n",
       " <__main__.AgentCar at 0x25a7ff1a490>,\n",
       " <__main__.AgentCar at 0x25a7ff1b7d0>,\n",
       " <__main__.AgentCar at 0x25a7ff1cb50>,\n",
       " <__main__.AgentCar at 0x25a7ff1de90>,\n",
       " <__main__.AgentCar at 0x25a7ff1f1d0>,\n",
       " <__main__.AgentCar at 0x25a7ff1ffd0>,\n",
       " <__main__.AgentCar at 0x25a7ff25890>,\n",
       " <__main__.AgentCar at 0x25a7ff26bd0>,\n",
       " <__main__.AgentCar at 0x25a7fba2fd0>,\n",
       " <__main__.AgentCar at 0x25a7fba18d0>,\n",
       " <__main__.AgentCar at 0x25a7fb7c650>,\n",
       " <__main__.AgentCar at 0x25a7fb83250>,\n",
       " <__main__.AgentCar at 0x25a7fb81b90>,\n",
       " <__main__.AgentCar at 0x25a7fb80290>,\n",
       " <__main__.AgentCar at 0x25a7fb7ac50>,\n",
       " <__main__.AgentCar at 0x25a7fb79450>,\n",
       " <__main__.AgentCar at 0x25a6cf10f90>,\n",
       " <__main__.AgentCar at 0x25a7fb726d0>,\n",
       " <__main__.AgentCar at 0x25a7fb85b10>,\n",
       " <__main__.AgentCar at 0x25a7fb84450>,\n",
       " <__main__.AgentCar at 0x25a7fb6ac90>,\n",
       " <__main__.AgentCar at 0x25a7fb69dd0>,\n",
       " <__main__.AgentCar at 0x25a7fbadad0>,\n",
       " <__main__.AgentCar at 0x25a7fbac390>,\n",
       " <__main__.AgentCar at 0x25a6ba11650>,\n",
       " <__main__.AgentCar at 0x25a6ba50510>,\n",
       " <__main__.AgentCar at 0x25a6cf30750>,\n",
       " <__main__.AgentCar at 0x25a6b966350>,\n",
       " <__main__.AgentCar at 0x25a7ff2c910>,\n",
       " <__main__.AgentCar at 0x25a7ff2dc50>,\n",
       " <__main__.AgentCar at 0x25a7ff2ef90>,\n",
       " <__main__.AgentCar at 0x25a7ff2ffd0>,\n",
       " <__main__.AgentCar at 0x25a7ff35650>,\n",
       " <__main__.AgentCar at 0x25a7ff36990>,\n",
       " <__main__.AgentCar at 0x25a7ff37cd0>,\n",
       " <__main__.AgentCar at 0x25a7ff3d050>,\n",
       " <__main__.AgentCar at 0x25a7ff3e390>,\n",
       " <__main__.AgentCar at 0x25a7ff3f6d0>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pickle\n",
    "file_name = \"all_points.pkl\"\n",
    "\n",
    "# car_chromosomes = [car.chromosome for car in cars]\n",
    "\n",
    "# print(\"Champion chromosomes:\")\n",
    "# print(car_chromosomes)\n",
    "\n",
    "# open_file = open(file_name, \"wb\")\n",
    "# pickle.dump(car_chromosomes, open_file)\n",
    "# open_file.close()\n",
    "\n",
    "open_file = open(file_name, \"rb\")\n",
    "loaded_list = pickle.load(open_file)\n",
    "open_file.close()\n",
    "\n",
    "new_cars = list()\n",
    "for i in range(len(loaded_list)):\n",
    "    car = AgentCar()\n",
    "    car.chromosome = loaded_list[i]\n",
    "    new_cars.append(car)\n",
    "new_cars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "293fb64e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'[0, 0, 0, 0, 0]': 1,\n",
       " '[0, 0, 0, 0, 1]': 4,\n",
       " '[0, 0, 0, 1, 0]': 1,\n",
       " '[0, 0, 0, 1, 1]': 1,\n",
       " '[0, 0, 1, 0, 0]': 3,\n",
       " '[0, 0, 1, 0, 1]': 2,\n",
       " '[0, 0, 1, 1, 0]': 3,\n",
       " '[0, 0, 1, 1, 1]': 4,\n",
       " '[0, 1, 0, 0, 0]': 1,\n",
       " '[0, 1, 0, 0, 1]': 2,\n",
       " '[0, 1, 0, 1, 0]': 2,\n",
       " '[0, 1, 0, 1, 1]': 4,\n",
       " '[0, 1, 1, 0, 0]': 4,\n",
       " '[0, 1, 1, 0, 1]': 3,\n",
       " '[0, 1, 1, 1, 0]': 1,\n",
       " '[0, 1, 1, 1, 1]': 2,\n",
       " '[1, 0, 0, 0, 0]': 1,\n",
       " '[1, 0, 0, 0, 1]': 1,\n",
       " '[1, 0, 0, 1, 0]': 4,\n",
       " '[1, 0, 0, 1, 1]': 1,\n",
       " '[1, 0, 1, 0, 0]': 3,\n",
       " '[1, 0, 1, 0, 1]': 2,\n",
       " '[1, 0, 1, 1, 0]': 1,\n",
       " '[1, 0, 1, 1, 1]': 2,\n",
       " '[1, 1, 0, 0, 0]': 1,\n",
       " '[1, 1, 0, 0, 1]': 1,\n",
       " '[1, 1, 0, 1, 0]': 3,\n",
       " '[1, 1, 0, 1, 1]': 1,\n",
       " '[1, 1, 1, 0, 0]': 1,\n",
       " '[1, 1, 1, 0, 1]': 1,\n",
       " '[1, 1, 1, 1, 0]': 1,\n",
       " '[1, 1, 1, 1, 1]': 1}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_list[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4763d87",
   "metadata": {},
   "source": [
    "# Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "66e47468",
   "metadata": {},
   "outputs": [],
   "source": [
    "pygame.font.init()\n",
    "\n",
    "MAIN_FONT = pygame.font.SysFont(\"Times New Roman\", 44)\n",
    "GRASS = scale_image(pygame.image.load(\"imgs/grass.jpg\"), 2.5)\n",
    "TRACK = scale_image(pygame.image.load(\"imgs/track.png\"), 0.9)\n",
    "TRACK_BORDER = scale_image(pygame.image.load(\"imgs/track-border.png\"), 0.9)\n",
    "TRACK_BORDER_MASK = pygame.mask.from_surface(TRACK_BORDER)\n",
    "FINISH = pygame.image.load(\"imgs/finish.png\")\n",
    "FINISH_MASK = pygame.mask.from_surface(FINISH)\n",
    "FINISH_POSITION = (130, 250)\n",
    "RED_CAR = scale_image(pygame.image.load(\"imgs/red-car.png\"), 0.40)\n",
    "CAR_WIDTH, CAR_HEIGHT = RED_CAR.get_width(), RED_CAR.get_height()\n",
    "\n",
    "checkpoint_image = pygame.image.load(\"imgs/finish.png\")\n",
    "checks = [\n",
    "            (130, 150),(130, 60), (110,30), (30,60) ,(0,150), (0, 250) ,(0,350),(90,550),(190,650),(350,650), #default checkpoints\n",
    "            (350,550), (400, 450), (500, 430),(530, 450), (550,550), (550,650), (700,650),(700,550), (700,450),(680,350), (630,320), (630, 220), (630,30), (550,30), (450,30), (350,30),\n",
    "            (700, 150),(230, 150),(230, 250),\n",
    "            (550,320),(550,200),(655,680)\n",
    "        ]\n",
    "checkpoints = list()\n",
    "\n",
    "highest_checkpoint_num = 0\n",
    "\n",
    "for position in checks:\n",
    "    if position in [(550,320),(550,200),(655,680),(110,30),(500, 430),(630,320) ,(630, 220),(630,30), (550,30), (450,30), (350,30)]:\n",
    "        checkpoint_mask = pygame.mask.from_surface(pygame.transform.rotate(checkpoint_image, 90))\n",
    "        checkpoints.append({\n",
    "            'image': pygame.transform.rotate(checkpoint_image, 90),\n",
    "            'mask': checkpoint_mask,\n",
    "            'position': position\n",
    "        })\n",
    "    elif position in [(130, 60),(530, 450),(680,350)]:\n",
    "        checkpoint_mask = pygame.mask.from_surface(pygame.transform.rotate(checkpoint_image, 45))\n",
    "        checkpoints.append({\n",
    "            'image': pygame.transform.rotate(checkpoint_image, 45),\n",
    "            'mask': checkpoint_mask,\n",
    "            'position': position\n",
    "        })\n",
    "\n",
    "    elif position in [(30, 60),(400, 450)]:\n",
    "        checkpoint_mask = pygame.mask.from_surface(pygame.transform.rotate(checkpoint_image, 135))\n",
    "        checkpoints.append({\n",
    "            'image': pygame.transform.rotate(checkpoint_image, 135),\n",
    "            'mask': checkpoint_mask,\n",
    "            'position': position\n",
    "        })\n",
    "    else:\n",
    "        checkpoint_mask = pygame.mask.from_surface(checkpoint_image)\n",
    "        checkpoints.append({\n",
    "            'image': checkpoint_image,\n",
    "            'mask': checkpoint_mask,\n",
    "            'position': position\n",
    "        })\n",
    "        \n",
    "clock = pygame.time.Clock()\n",
    "images = [(GRASS, (0, 0)), (TRACK, (0, 0)), (FINISH, FINISH_POSITION)]\n",
    "WIDTH, HEIGHT = 800,800\n",
    "WIN = pygame.display.set_mode((WIDTH, HEIGHT))\n",
    "pygame.display.set_caption(\"Genetic Algorithm on cars! (Assignment #3)\")\n",
    "    \n",
    "game_info = GameInfo()\n",
    "max_time = 50\n",
    "\n",
    "max_for_this_gen = 0\n",
    "\n",
    "new_cars = list()\n",
    "for i in range(len(loaded_list)):\n",
    "    car = AgentCar()\n",
    "    car.chromosome = loaded_list[i]\n",
    "    new_cars.append(car)\n",
    "\n",
    "active_cars = len(new_cars)\n",
    "\n",
    "\n",
    "\n",
    "while game_info.get_level_time() < max_time and active_cars > 0:\n",
    "\n",
    "\n",
    "    if game_info.started == False:\n",
    "        game_info.start_level()\n",
    "\n",
    "    draw(WIN, images, new_cars, max_time - game_info.get_level_time(),checkpoints,active_cars, \"Test\", highest_checkpoint_num, \"\")\n",
    "\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT:\n",
    "            break\n",
    "\n",
    "    active_cars = 0\n",
    "    for car in new_cars:\n",
    "        if car.active:\n",
    "            active_cars+=1\n",
    "            car.sensorControl()\n",
    "            car.move_car()\n",
    "            handle_collision(car, checkpoints, FINISH_MASK)\n",
    "            highest_checkpoint_num = max(highest_checkpoint_num, car.checkpoints)\n",
    "            \n",
    "pygame.quit()  "
   ]
  }
 ],
 "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}