gui_util.py

import math
import os
import pygame
from PIL import Image
from advanced_view.gauge import GaugeDraw
from pygame import gfxdraw
from random import randint

from car import MAX_SPEED, VISION_F, VISION_W, VISION_B
import config
from config import ROAD_VIEW_OFFSET, INPUT_VIEW_OFFSET_X, INPUT_VIEW_OFFSET_Y


pygame.font.init()
font_28 = pygame.font.Font(os.path.join('./advanced_view/fonts/digitize.ttf'), 28)
font_60 = pygame.font.Font(os.path.join('./advanced_view/fonts/digitize.ttf'), 60)


class Point:
    # constructed using a normal tupple
    def __init__(self, point_t = (0,0)):
        self.x = float(point_t[0])
        self.y = float(point_t[1])

    # define all useful operators
    def __add__(self, other):
        return Point((self.x + other.x, self.y + other.y))

    def __sub__(self, other):
        return Point((self.x - other.x, self.y - other.y))

    def __mul__(self, scalar):
        return Point((self.x*scalar, self.y*scalar))

    def __div__(self, scalar):
        return Point((self.x/scalar, self.y/scalar))

    def __len__(self):
        return int(math.sqrt(self.x**2 + self.y**2))

    # get back values in original tuple format
    def get(self):
        return self.x, self.y


black = pygame.Color(0, 0, 0)
white = pygame.Color(255, 255, 255)
grey = pygame.Color(128, 128, 128)
yellow = pygame.Color(255, 255, 0, 128)
orange = pygame.Color(255, 140, 0, 128)

IMAGE_PATH = './images'

if config.VISUALENABLED:
    accelerate_on = pygame.image.load(os.path.join(IMAGE_PATH, 'accelerate_on.png'))
    accelerate_off = pygame.image.load(os.path.join(IMAGE_PATH, 'accelerate_off.png'))
    brake_on = pygame.image.load(os.path.join(IMAGE_PATH, 'brake_on.png'))
    brake_off = pygame.image.load(os.path.join(IMAGE_PATH, 'brake_off.png'))
    left_on = pygame.image.load(os.path.join(IMAGE_PATH, 'left_on.png'))
    left_off = pygame.image.load(os.path.join(IMAGE_PATH, 'left_off.png'))
    right_on = pygame.image.load(os.path.join(IMAGE_PATH, 'right_on.png'))
    right_off = pygame.image.load(os.path.join(IMAGE_PATH, 'right_off.png'))


def draw_dashed_line(surf, color, start_pos, end_pos, width=1, dash_length=10):
    if not config.VISUALENABLED:
        return

    origin = Point(start_pos)
    target = Point(end_pos)
    displacement = target - origin
    length = len(displacement)
    slope = displacement/length
    loop = length / dash_length

    for index in range(0, loop, 2):
        start = origin + (slope * index * dash_length)
        end = origin + (slope * (index + 1) * dash_length)
        gfxdraw.filled_polygon(surf, (
            (int(start.x), int(start.y)),
            (int(start.x) + width, int(start.y)),
            (int(end.x) + width, int(end.y)),
            (int(end.x), int(end.y))
        ), color)


def draw_dashed_line_delay(surf, color, start_pos, end_pos, width=1, dash_length=10, delay=0):
    if not config.VISUALENABLED:
        return

    origin = Point(start_pos)
    target = Point(end_pos)
    displacement = target - origin
    length = len(displacement)
    slope = displacement/length
    loop = length / dash_length

    origin = origin + (slope * delay * 10)

    for index in range(0, loop + 1, 2):
        start = origin + (slope * index * dash_length)
        end = origin + (slope * (index + 1) * dash_length)
        gfxdraw.filled_polygon(surf, (
            (int(start.x), int(start.y)),
            (int(start.x) + width, int(start.y)),
            (int(end.x) + width, int(end.y)),
            (int(end.x), int(end.y))
        ), color)


def draw_basic_road(surface, speed):
    if not config.VISUALENABLED:
        return

    surface.fill(white)
    # Left most lane marking
    pygame.draw.line(surface, black, (ROAD_VIEW_OFFSET + 13, -10), (ROAD_VIEW_OFFSET + 13, 1000), 5)
    # Right most lane marking
    pygame.draw.line(surface, black, (ROAD_VIEW_OFFSET + 367, -10), (ROAD_VIEW_OFFSET + 367, 1000), 5)

    line_marking_offset = randint(0, 10)
    for l in range(1, 7):
        draw_dashed_line(
            surface,
            grey,
            (ROAD_VIEW_OFFSET + l * 50 + 15, int((speed/(MAX_SPEED * 1.0)) * -1 * line_marking_offset)),
            (ROAD_VIEW_OFFSET + l * 50 + 15, 1000),
            width=1,
            dash_length=5
        )


def draw_road_overlay_safety(surface, lane_map):
    if not config.VISUALENABLED:
        return

    # Draw on surface
    for y in range(100):
        for x in range(7):
            if lane_map[y][x] != 0:
                pygame.draw.rect(surface, yellow, (ROAD_VIEW_OFFSET + x * 50 + 15 + 1, y * 10, 49, 10))
                pygame.draw.rect(surface, grey, (ROAD_VIEW_OFFSET + x * 50 + 15 + 1, y * 10, 49, 10), 1)


def draw_road_overlay_vision(surface, subject_car):
    if not config.VISUALENABLED:
        return

    # Draw on surface
    min_x = min(max(0, subject_car.lane - VISION_W - 1), 6)
    max_x = min(max(0, subject_car.lane + VISION_W - 1), 6)

    min_y = min(max(0, int(math.ceil(subject_car.y / 10.0)) - VISION_F - 1), 100)
    max_y = min(max(0, int(math.ceil(subject_car.y / 10.0)) + VISION_B - 1), 100)

    for y in range(min_y, max_y + 1):
        for x in range(min_x, max_x + 1):
            pygame.draw.rect(surface, orange, (ROAD_VIEW_OFFSET + x * 50 + 15 + 1, y * 10, 49, 10))
            pygame.draw.rect(surface, grey, (ROAD_VIEW_OFFSET + x * 50 + 15 + 1, y * 10, 49, 10), 1)


def control_car(target_car, keydown):
    if keydown == pygame.K_UP:
        target_car.move('A')
    elif keydown == pygame.K_DOWN:
        target_car.move('D')
    else:
        target_car.move('M')

    if keydown == pygame.K_LEFT:
        target_car.switch_lane('L')
    elif keydown == pygame.K_RIGHT:
        target_car.switch_lane('R')


def identify_free_lane(cars):
    lanes = [[n for n in range(1, 8)] for _ in range(2)]
    for car in cars:
        if -170 <= car.y <= 0:
            if car.lane in lanes[0]:
                lanes[0].remove(car.lane)
            if car.switching_lane in lanes[0]:
                lanes[0].remove(car.switching_lane)
        elif 930 <= car.y <= 1070:
            if car.lane in lanes[1]:
                lanes[1].remove(car.lane)
            if car.switching_lane in lanes[1]:
                lanes[1].remove(car.switching_lane)

    return lanes


def draw_inputs(surface, vision):
    vision_title = font_28.render("Vision:", False, (0, 0, 0))
    surface.blit(vision_title, (INPUT_VIEW_OFFSET_X - 10, INPUT_VIEW_OFFSET_Y))
    for y_i in range(len(vision)):
        for x_i, x in enumerate(vision[y_i]):
            pygame.draw.rect(surface, orange if x != 0 else white,
                             (INPUT_VIEW_OFFSET_X + x_i * 10 + 80, INPUT_VIEW_OFFSET_Y + y_i * 10, 10, 10))
            pygame.draw.rect(surface, grey,
                             (INPUT_VIEW_OFFSET_X + x_i * 10 + 1 + 80, INPUT_VIEW_OFFSET_Y + y_i * 10, 10, 10), 1)


def draw_actions(surface, action):
    action_title = font_28.render("Action:", False, (0, 0, 0))
    surface.blit(action_title, (INPUT_VIEW_OFFSET_X - 10, INPUT_VIEW_OFFSET_Y + 370))

    surface.blit(left_on if action == 'L' else left_off,
                 (INPUT_VIEW_OFFSET_X + 80, INPUT_VIEW_OFFSET_Y + 370, 34, 70))
    surface.blit(right_on if action == 'R' else right_off,
                 (INPUT_VIEW_OFFSET_X + 80 + 40, INPUT_VIEW_OFFSET_Y + 370, 34, 70))
    surface.blit(brake_on if action == 'D' else brake_off,
                 (INPUT_VIEW_OFFSET_X + 80, INPUT_VIEW_OFFSET_Y + 410, 34, 70))
    surface.blit(accelerate_on if action == 'A' else accelerate_off,
                 (INPUT_VIEW_OFFSET_X + 80 + 40, INPUT_VIEW_OFFSET_Y + 410, 34, 70))


class Score:
    def __init__(self, score=0):
        self.score = score

    def add(self):
        self.score += 1
        # self.score -= 0.1

    def subtract(self):
        self.score -= 1
        # self.score -= 0.1

    def penalty(self):
        # Penalty over time
        self.score += config.CONSTANT_PENALTY

    def brake_penalty(self):
        self.score += config.EMERGENCY_BRAKE_PENALTY

    def action_mismatch_penalty(self):
        self.score += config.MISMATCH_ACTION_PENALTY

    def switching_lane_penalty(self):
        self.score += config.SWITCHING_LANE_PENALTY


def draw_gauge(surface, speed):
    im = Image.new("RGB", (200, 200), (255, 255, 255, 0))
    g = GaugeDraw(im, 0, 110)
    g.render_simple_gauge(value=speed, major_ticks=10, minor_ticks=5, label="{}kmh".format(speed))

    gauge = pygame.image.fromstring(im.tobytes(), im.size, im.mode)

    speed_title = font_28.render("Speed:", False, (0, 0, 0))
    surface.blit(speed_title, (INPUT_VIEW_OFFSET_X - 10, 10))
    surface.blit(gauge, ((INPUT_VIEW_OFFSET_X - 10, 35), (200, 200)))


def draw_score(surface, score):
    score_title = font_28.render("Score:", False, (0, 0, 0))
    score = font_60.render(str(int(score)), False, (0, 0, 0))
    surface.blit(score_title, (INPUT_VIEW_OFFSET_X - 10, 245))
    surface.blit(score, (INPUT_VIEW_OFFSET_X - 10 + 80, 240))