Merge branch 'release/release-0.1'

advanced_view/road.py

@@ -1,49 +1,188 @@
 import pygame
+from pygame import gfxdraw
 import os
+from PIL import Image
+from PIL import ImageDraw
+
+from gui_util import draw_dashed_line_delay
+
+ROAD_HEIGHT = 250.0
+
+
+COLOR = {"white": pygame.Color(255, 255, 255),
+         "opaque_white": pygame.Color(255, 255, 255, 80),
+         "text": pygame.Color(172, 199, 252),
+         "dark_text": pygame.Color(57, 84, 137),
+         "selection": [pygame.Color(172, 199, 252), pygame.Color(100, 149, 252)],
+         "sky": pygame.Color(10, 10, 10),
+         "gutter": pygame.Color(100, 100, 100),
+         "red": pygame.Color(204, 0, 0),
+         "bonus_a": pygame.Color(255, 78, 0),
+         "bonus_b": pygame.Color(255, 178, 0),
+         "green": pygame.Color(32, 76, 1),
+         "black": pygame.Color(0, 0, 0),
+         "tunnel": pygame.Color(38, 15, 8),
+         "brown": pygame.Color(124, 69, 1)}
 
 
 class AdvancedRoad:
-    def __init__(self, surface, origin_x, origin_y, width, height):
+    def __init__(self, surface, origin_x, origin_y, width, height, lane=6):
         self.surface = surface
-        self.origin_x = origin_x
-        self.origin_y = origin_y
-        self.width = width
-        self.height = height
+        self.sky_x = 0
+        self.sky_y = 0
+        self.sky_height = 800 - ROAD_HEIGHT
+        self.sky_width = width
+        self.origin_x = origin_x # Road origin_x
+        self.origin_y = origin_y # Road origin_y
+        self.width = width # Road width
+        self.height = height # Road height
+        self.lane = lane
 
-        self.road_image = pygame.image.load(os.path.join('./advanced_view/images/road_perspective_0.png'))
-        self.road_image = pygame.transform.scale(self.road_image, (2150, 515))
+        self.sky_image = pygame.image.load(os.path.join('./advanced_view/images/sky_1010x550.png'))
+        self.hill_image = pygame.image.load(os.path.join('./advanced_view/images/hill.png'))
+        self.field_left_image = pygame.image.load(os.path.join('./advanced_view/images/field_left.png'))
+        self.field_right_image = pygame.image.load(os.path.join('./advanced_view/images/field_right.png'))
+        self.field_side_left_image = pygame.image.load(os.path.join('./advanced_view/images/field_side_left.png'))
+        self.field_side_right_image = pygame.image.load(os.path.join('./advanced_view/images/field_side_right.png'))
+        self.field_image = Image.open(os.path.join('./advanced_view/images/field.png')).convert("RGBA")
+        # self.dirt_image = pygame.image.load(os.path.join('./advanced_view/images/dirt.png'))
+        self.dirt_image = Image.open(os.path.join('./advanced_view/images/dirt.png')).convert("RGBA")
+        self.subject_car_middle_image = pygame.image.load(os.path.join('./advanced_view/images/chev_rear.png'))
+        self.subject_car_left_image = pygame.image.load(os.path.join('./advanced_view/images/chev_left.png'))
+        self.subject_car_right_image = pygame.image.load(os.path.join('./advanced_view/images/chev_right.png'))
+        self.object_car_middle_image = pygame.image.load(os.path.join('./advanced_view/images/civic_rear.png'))
+        self.object_car_left_image = pygame.image.load(os.path.join('./advanced_view/images/civic_left.png'))
+        self.object_car_right_image = pygame.image.load(os.path.join('./advanced_view/images/civic_right.png'))
 
-        self.marker_images = []
-        marker_image = pygame.image.load(os.path.join('./advanced_view/images/marker_0.png'))
-        marker_image = pygame.transform.scale(marker_image, (2150, 515))
-        self.marker_images.append(marker_image)
-        marker_image = pygame.image.load(os.path.join('./advanced_view/images/marker_1.png'))
-        marker_image = pygame.transform.scale(marker_image, (2150, 515))
-        self.marker_images.append(marker_image)
+        self.road_view = None
 
-        self.subject_car_image = pygame.image.load(os.path.join('./advanced_view/images/tesla.png'))
-        self.subject_car_image = pygame.transform.scale(self.subject_car_image, (165, 112))
+    def draw(self, frame, subject_car):
+        lane = subject_car.lane
+        while True:
+            self.draw_sky(frame)
+            self.draw_road_side(frame, self.lane)
+            self.draw_road(frame, lane=self.lane)
+            self.draw_cars(subject_car)
+            self.draw_subject_car(self.lane - lane)
+            if self.lane != lane:
+                self.lane += 0.25 if lane > self.lane else - 0.25
+            if abs(self.lane - lane) < 0.1:
+                break
+            pygame.event.poll()
+            pygame.display.flip()
+        self.lane = lane
 
-        self.road_view = None
+    def draw_sky(self, frame):
+        view = pygame.Surface((self.sky_width, self.sky_height))
+        # Resize sky
+        if frame % 40 == 0:
+            self.sky_image = pygame.transform.scale(self.sky_image, (self.sky_image.get_size()[0]+2, self.sky_image.get_size()[1]+1))
+            self.sky_image.blit(self.sky_image, ((-1, -2), (self.sky_width, self.sky_height)))
+        view.blit(self.sky_image, ((0, 0), (self.sky_width, self.sky_height)))
+        view.blit(self.hill_image, ((0, self.sky_height - 49), (self.sky_width, 49)))
+        self.surface.blit(view, ((self.sky_x, self.sky_y), (self.sky_width, self.sky_height)))
+
+    def draw_cars(self, subject_car):
+        view = pygame.Surface((1010, ROAD_HEIGHT), pygame.SRCALPHA, 32)
+        view = view.convert_alpha()
+        camera_lane = subject_car.lane
+        cars = subject_car.get_subjective_vision()
+        for car in cars:
+            lane = car[0]
+            y = car[1]
+            relative_y = y - 42
+            if relative_y < 0:
+                continue
+
+            image = self.object_car_middle_image
+            ratio = 231.0 / 328.0
+            if lane != camera_lane:
+                if lane > camera_lane:
+                    image = self.object_car_right_image
+                else:
+                    image = self.object_car_left_image
+            pt_top_left = (lane - 1) * 100.0 / 7 + 455
+            pt_top_right = lane * 100.0 / 7 + 455
+            pt_bottom_left = -337.0 * camera_lane + 673.33 + (lane - 1) * 337.0
+            pt_bottom_right = -337.0 * camera_lane + 673.33 + lane * 337.0
+            target_y = ROAD_HEIGHT * relative_y / 28.0
+            target_bottom_left_x = pt_top_left + target_y / ROAD_HEIGHT * (pt_bottom_left - pt_top_left)
+            target_bottom_right_x = pt_top_right + target_y / ROAD_HEIGHT * (pt_bottom_right - pt_top_right)
+            image_width = int(target_bottom_right_x - target_bottom_left_x - 10)
+            image_width = image_width if image_width > 0 else 0
+            image_height = int(image_width * ratio)
+            target_top_left_x = int(target_bottom_left_x + 5)
+            target_top_left_y = int(target_y - image_height)
+            a = pygame.transform.scale(image, (image_width, image_height))
+            view.blit(a, (target_top_left_x, target_top_left_y))
+        self.surface.blit(view, ((self.origin_x, self.origin_y), (self.width, self.height)))
+
+    def draw_road_side(self, frame, lane):
+        polygon_left = [
+            (-337.0 * lane + 673.33 - 200, ROAD_HEIGHT),
+            (455 - 20, 0),
+            (0, 0),
+            (0, ROAD_HEIGHT)]
+        polygon_right = [
+            (1010, ROAD_HEIGHT),
+            (1010, 0),
+            (555 + 20, 0),
+            (-336.67 * lane + 3032 + 200, ROAD_HEIGHT)]
+        maskIm = self.dirt_image.crop((0, 500 - (frame % 20) * 25, self.width, ROAD_HEIGHT + 500 - (frame % 20) * 25))
+        pdraw = ImageDraw.Draw(maskIm)
+        pdraw.polygon(polygon_left, fill=(255, 255, 255, 0), outline=(255, 255, 255, 0))
+        pdraw.polygon(polygon_right, fill=(255, 255, 255, 0), outline=(255, 255, 255, 0))
+        side = self.field_image.crop((0, 500 - (frame % 20) * 25, self.width, ROAD_HEIGHT + 500 - (frame % 20) * 25))
+        side.paste(maskIm, (0, 0), mask=maskIm)
+        side_pygame = pygame.image.fromstring(side.tobytes(), side.size, side.mode)
+        self.surface.blit(side_pygame, ((self.origin_x, self.origin_y), (self.width, ROAD_HEIGHT)))
+
+    def blit_mask(source, dest, destpos, mask, maskrect):
+        """
+        Blit an source image to the dest surface, at destpos, with a mask, using
+        only the maskrect part of the mask.
+        """
+        tmp = source.copy()
+        tmp.blit(mask, maskrect.topleft, maskrect, special_flags=pygame.BLEND_RGBA_MULT)
+        dest.blit(tmp, destpos, dest.get_rect().clip(maskrect))
+
+    def draw_road(self, frame, lane=1):
+        self.road_view = pygame.Surface((1010, ROAD_HEIGHT), pygame.SRCALPHA, 32)
+        self.road_view = self.road_view.convert_alpha()
+
+        pygame.draw.polygon(self.road_view, COLOR['black'],
+                            [
+                                (-337.0 * lane + 673.33, ROAD_HEIGHT),
+                                (455, 0),
+                                (555, 0),
+                                (-336.67 * lane + 3032, ROAD_HEIGHT)
+                            ])
+
+        left = -337.0 * lane + 673.33
+        for i in range(8):
+            if i == 0 or i == 7:
+                gfxdraw.filled_polygon(self.road_view, (
+                    (int(int(i * 100.0 / 7 + 455)), 0),
+                    (int(int(i * 100.0 / 7 + 455)) + 7, 0),
+                    (int(left) + 7, int(ROAD_HEIGHT)),
+                    (int(left), int(ROAD_HEIGHT))
+                ), COLOR['white'])
+            else:
+                draw_dashed_line_delay(self.road_view,
+                                 COLOR['white'],
+                                 (i * 100.0 / 7 + 455, 0),
+                                 (left, ROAD_HEIGHT),
+                                 width=5,
+                                 dash_length=40,
+                                 delay=frame % 3)
+            left += 337.0
 
-    def animate_road_marker(self, frame, angle=0):
-        return
-        size = self.road_image.get_rect().size
-        marker_driving_view = pygame.Surface((1010, 500), pygame.SRCALPHA, 32)
-        marker_driving_view.blit(self.marker_images[frame % 2], (0, 0), (size[0] / 4.0, 0, 3 / 4.0 * size[0], size[1]))
-        marker_driving_view = marker_driving_view.convert_alpha()
-        self.surface.blit(marker_driving_view, ((self.origin_x, self.origin_y), (self.width, self.height)))
-
-    def draw_road(self, frame, redraw=False, angle=0):
-        # return
-        if redraw or self.road_view is None:
-            size = self.road_image.get_rect().size
-            driving_view = pygame.Surface((1010, 500), pygame.SRCALPHA, 32)
-            driving_view.blit(self.road_image, (0, 0), (size[0] / 4.0, 0, 3 / 4.0 * size[0], size[1]))
-            # driving_view.blit(marker_images[frame % 2], (0, 0), (size[0]/4.0, 0, 3 / 4.0 * size[0], size[1]))
-            self.road_view = driving_view.convert_alpha()
         self.surface.blit(self.road_view, ((self.origin_x, self.origin_y), (self.width, self.height)))
 
-    def draw_subject_car(self):
-        # return
-        self.surface.blit(self.subject_car_image, (self.origin_x + 460, self.origin_y + 350))
+    def draw_subject_car(self, direction):
+        image = self.subject_car_middle_image
+        if direction > 0:
+            image = self.subject_car_left_image
+        elif direction < 0:
+            image = self.subject_car_right_image
+        self.surface.blit(image, (self.origin_x + 345, self.origin_y + 70))

car.py

@@ -8,7 +8,9 @@
 from players.sticky_player import StickyPlayer
 from players.deep_traffic_player import DeepTrafficPlayer
 
-from config import VISION_B, VISION_F, VISION_W, VISUALENABLED, EMERGENCY_BRAKE_MAX_SPEED_DIFF, ROAD_VIEW_OFFSET
+from config import VISION_B, VISION_F, VISION_W, \
+    VISUALENABLED, EMERGENCY_BRAKE_MAX_SPEED_DIFF, ROAD_VIEW_OFFSET, \
+    VISUAL_VISION_B, VISUAL_VISION_F, VISUAL_VISION_W
 
 
 MAX_SPEED = 110  # km/h
@@ -63,6 +65,9 @@ def __init__(self, surface, lane_map, speed=0, y=0, lane=4, is_subject=False, su
                 StickyPlayer(self)
             ]) if not self.is_subject else DeepTrafficPlayer(self, agent=agent)
 
+        self.hard_brake_count = 0
+        self.alternate_line_switching = 0
+
     def identify(self):
         min_box = int(math.floor(self.y / 10.0)) - 1
         max_box = int(math.ceil(self.y / 10.0))
@@ -124,15 +129,17 @@ def switch_lane(self, direction):
                     self.switching_lane = self.lane + 1
                     self.identify()
                 else:
-                    self.score.action_mismatch_penalty()
+                    if self.subject is None:
+                        self.score.action_mismatch_penalty()
                     return 'M'
         if direction == 'L':
             if 'L' in directions:
                 if self.lane > 1:
                     self.switching_lane = self.lane - 1
                     self.identify()
                 else:
-                    self.score.action_mismatch_penalty()
+                    if self.subject is None:
+                        self.score.action_mismatch_penalty()
                     return 'M'
         return direction
 
@@ -216,6 +223,8 @@ def relative_pos_subject(self):
         if self.is_subject:
             if self.emergency_brake is not None and self.emergency_brake > EMERGENCY_BRAKE_MAX_SPEED_DIFF:
                 self.score.brake_penalty()
+                self.hard_brake_count += 1
+            self.emergency_brake = None
             return
         dvdt = self.speed - self.subject.speed
         dmds = dvdt / 3.6
@@ -233,11 +242,18 @@ def relative_pos_subject(self):
 
     def decide(self, end_episode, cache=False, is_training=True):
         if self.subject is None:
-            return self.player.decide_with_vision(self.get_vision(),
+            q_values, result = self.player.decide_with_vision(self.get_vision(),
                                                   self.score.score,
                                                   end_episode,
                                                   cache=cache,
                                                   is_training=is_training)
+            # Check for recent lane switching
+            if result == 'L' or result == 'R':
+                if (result == 'L' and 4 in self.player.agent.previous_actions) or \
+                        (result == 'R' and 3 in self.player.agent.previous_actions):
+                    self.score.switching_lane_penalty()
+                    self.alternate_line_switching += 1
+            return q_values, result
         else:
             return self.player.decide(end_episode, cache=cache)
 
@@ -281,3 +297,21 @@ def get_vision(self):
         vision = np.reshape(vision, [VISION_F + VISION_B + 1, VISION_W * 2 + 1, 1])
         return vision
 
+    def get_subjective_vision(self):
+        min_x = min(max(0, self.lane - 1 - VISUAL_VISION_W), 6)
+        max_x = min(max(0, self.lane - 1 + VISUAL_VISION_W), 6)
+        input_min_xx = self.lane - 1 - VISUAL_VISION_W
+        input_max_xx = self.lane - 1 + VISUAL_VISION_W
+
+        input_min_y = int(math.floor(self.y / 10.0)) - VISUAL_VISION_F
+        input_max_y = int(math.floor(self.y / 10.0)) + VISUAL_VISION_B
+        min_y = min(max(0, input_min_y), 100)
+        max_y = min(max(0, input_max_y), 100)
+
+        cars = [
+            (self.lane_map[y][x].lane, int(math.floor(self.lane_map[y][x].y / 10.0)))
+            for y in range(min_y, max_y + 1)
+            for x in range(min_x, max_x + 1)
+            if self.lane_map[y][x] != 0 and self.lane_map[y][x].subject is not None]
+
+        return cars