def test_removeCars(self):
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.removeCars(lane, "LEFT")
self.assertEqual(lane, [car1, car2, car3])
def test_countCars(self):
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
answer = simulator.countCars(lane, "LEFT")
self.assertEqual(answer, 2)
def test_carAttr(self):
"""
Test the attributes are set correctly
"""
car = Car("Car1", "WEST", "LEFT")
self.assertEqual(car.getName(), "Car1")
self.assertEqual(car.getEnter(), "WEST")
self.assertEqual(car.getDirection(), "LEFT")
def test_car_speed(self):
man = Car('MAN', 'Truck', 'trailer')
parked_speed = man.speed
moving_speed = man.drive(7).speed
self.assertListEqual([parked_speed, moving_speed],
[0, 77],
msg='The Trailer should have speed 0 km/h until you put `the pedal to the metal`')
def test_drive_car(self):
man = Car('MAN', 'Truck', 'trailer')
moving_man = man.drive(7)
moving_man_instance = isinstance(moving_man, Car)
moving_man_type = type(moving_man) is Car
self.assertListEqual([True, True, man.speed],
[moving_man_instance, moving_man_type, moving_man.speed],
msg='The car drive function should return the instance of the Car class')
def test_car_speed2(self):
man = Car('Mercedes', 'SLR500')
parked_speed = man.speed
moving_speed = man.drive(3).speed
self.assertListEqual([parked_speed, moving_speed],
[0, 1000],
msg='The Mercedes should have speed 0 km/h until you put `the pedal to the metal`')
def setUp(self):
make = "GM"
self.model = "Malibu"
year = 2020
self.price = 40000
self.km = 10000
self.avto1 = Car(make, self.model, year)
self.avto2 = Car(make, self.model, year, price=self.price)
def test_removeCars(self):
"""
Test for removing cars
"""
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
eastLane = [car1, car2, car3, car3]
simulator.removeCars(eastLane, "LEFT")
self.assertEqual(eastLane, [car1, car2, car3])
def test_countAllCars(self):
"""
Used to test the counnt all cars method
"""
controller = TrafficLightController("TEST")
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
self.assertEqual(simulator.CountAllCars(lane), (1, 3))
def test_lightSignalsLogic(self):
"""
Tests our logic for our light signals
"""
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
car4 = Car("Car4", "NORTH", "RIGHT")
testFunctions.eastLane = [car1, car2, car3]
testFunctions.northLane = [car4, car4]
self.assertEqual(testFunctions.lightSignals(), ("eo", "er"))
def test_sensorAllGo(self):
controller = TrafficLightController("MOCK")
tl = controller.getTL()
tl.switchOff()
tl.greenOn()
tl.tgreenOn()
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.sensor(controller, lane)
self.assertEqual(lane, [car2, car3, car3])
def test_lightSignalWaitLogicTwo(self):
"""
Test further logic behind the wait times
"""
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
car4 = Car("Car4", "NORTH", "RIGHT")
car5 = Car("Car5", "NORTH", "STRAIGHT")
testFunctions.eastLane = [car1, car2, car3]
testFunctions.northLane = [car4, car5]
testFunctions.northController.wait_other = 7 # test border value
self.assertEqual(testFunctions.lightSignals(), ("eo", "er"))
def leading_car(self, car):
"""Returns the next car.
TODO: don't limit ourselves to the current arc.
"""
next_car = Car(car.arc, 0, float('Inf'))
next_car.total_distance = float('Inf')
for other_car in self.cars:
if all((other_car.total_distance > car.total_distance,
other_car.total_distance < next_car.total_distance)):
next_car = other_car
return next_car
def __init__(self):
pygame.init()
self.window = pygame.display.set_mode((500, 800))
pygame.display.set_caption("Racing AI")
self.clock = pygame.time.Clock()
self.execute = True
self.car = Car(250, 650, self.window)
self.agent = DQNAgent(inputs=4, n_actions=2)
self.episode_durations = []
self.update_agent = pygame.USEREVENT + 1
update_timer = 100
pygame.time.set_timer(self.update_agent, update_timer)
def test_sensorStraightOrange(self):
"""
Test straight orange lights
"""
controller = TrafficLightController("MOCK")
tl = controller.getTL()
tl.switchOff()
tl.tredOn()
tl.orangeOn()
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.sensor(controller, lane)
self.assertEqual(lane, [car2, car3])
def main():
"""Demo test code to show how to use car class."""
my_car = Car("Car", 180)
my_car.drive(30)
print("fuel =", my_car.fuel)
print("odo =", my_car.odometer)
print(my_car)
print("Car {}, {}".format(my_car.fuel, my_car.odometer))
print("Car {self.fuel}, {self.odometer}".format(self=my_car))
limo = Car("limo", 100)
limo.add_fuel(20)
print("The {} has {} units of fuel. The odometer reads: {}".format(limo.name, limo.fuel, limo.odometer))
limo.drive(115)
print("The {} has {} units of fuel. The odometer reads: {}".format(limo.name, limo.fuel, limo.odometer))
def add_car(self):
if input("Is the car a supercar? (y/n): ") == "y":
model = input("What model is the car?: ")
self.__cars.append(Supercar(model)) # Instantiate Supercar
else:
model = input("What model is the car?: ")
self.__cars.append(Car(model)) # Instantiate Car
def __init__(self, num_of_genes, map_handler, end_spread, mutation_rate,
pop_size):
"""Sets up the object and creates the initial population of Car objects.
Args:
num_of_genes (int): The number of genes per car.
map_handler (MapHandler obj): An object for controlling the map.
end_spread (int): The number of genes to remove and replace from the end of the gene list.
mutation_rate (float): The chance of the Dna to mutate.
pop_size (int): The number of Cars in the population.
"""
self.population = [] # Array to hold the current population
self.mating_pool = [] # List which we will use for our "mating pool"
self.generations = 0 # Number of generations
self.finished = False # Are we finished evolving?
self.map_handler = map_handler
self.mutation_rate = mutation_rate
self.num_of_genes = num_of_genes
self.end_spread = end_spread
self.start_point = map_handler.find_line_midpoint(
self.map_handler.starting_line)
# Creates the population of cars with random genes
for id in range(0, pop_size):
self.population.append(
Car(self.map_handler, self.start_point, self.num_of_genes,
self.end_spread, id))
def test_lightSignalWaitLogic(self):
"""
Tests the logic being wait times in light signals
"""
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
car4 = Car("Car4", "NORTH", "RIGHT")
car5 = Car("Car5", "NORTH", "STRAIGHT")
testFunctions.eastLane = [car1, car2, car3]
testFunctions.northLane = [car4, car5, car4]
for i in range(10):
# Force wait to be tripped
testFunctions.northController.IncrementOtherWait()
self.assertEqual(testFunctions.lightSignals(), ("no", "nr"))
def run_tests():
"""Run the tests on the functions."""
# assert test with no message - used to see if the function works properly
assert repeat_string("Python", 1) == "Python"
# the test below should fail
repeat_string("hi", 2)
assert repeat_string("hi", 2) == "hi hi"
test_car = Car()
assert test_car.odometer == 0, "Car does not set odometer correctly"
test_car = Car(fuel=10)
assert test_car.fuel == 10
test_car = Car()
assert test_car.fuel == 0
def test_lightsBrokenLogic(self):
"""
Tests lightsAreBroken works as intended
"""
simulator.lightsAreBroken = True
controller = TrafficLightController("TEST")
tl = controller.getTL()
tl.switchOff()
tl.greenOn()
tl.tgreenOn()
car1 = Car("Car1", "EAST", "STRAIGHT")
car2 = Car("Car2", "EAST", "RIGHT")
car3 = Car("Car3", "EAST", "LEFT")
lane = [car1, car2, car3, car3]
simulator.sensor(controller, lane)
self.assertEqual(lane, [car1, car2, car3, car3])
# Reset the variable so as not to break anything
simulator.lightsAreBroken = False
def run(self):
while True:
self.main_menu()
user_input = input()
if user_input == "1":
i = 0
print(
"Please answer the following questions for your top 5 dream cars"
)
while len(self.car_list) < 5:
i += 1
print(f"Car #{i}")
make = self.questions.make()
model = self.questions.model()
year = self.questions.year()
color = self.questions.color()
rank = self.questions.rank()
self.car_list.append(
Car(make=make,
model=model,
year=year,
color=color,
rank=rank))
user_input = None
while user_input != "6":
self.sorting_menu()
user_input = input()
if user_input == "1":
self.sort.sort_by_entry(car_list=self.car_list)
elif user_input == "2":
self.sort.sort_by_ranking(car_list=self.car_list)
elif user_input == "3":
self.sort.sort_by_year(car_list=self.car_list)
elif user_input == "4":
self.sort.sort_by_make(car_list=self.car_list)
elif user_input == "5":
self.sort.random_sort(car_list=self.car_list)
elif user_input == "6":
break
else:
print('try again')
elif user_input == "2":
break
else:
print("Not an option, try again")
print(self.car_list)
def crossover(self):
"""Constructs a new generation using the mating pool."""
# Refill the population with children from the mating pool
for i in range(len(self.population)):
# Pick two parents from the mating pool
a = randrange(0, len(self.mating_pool))
b = randrange(0, len(self.mating_pool))
partnerA = self.mating_pool[a]
partnerB = self.mating_pool[b]
child = partnerA.crossover(partnerB, self.mutation_rate)
# Create a new member of the population by overriding the old one
self.population[i] = \
Car(self.map_handler, self.start_point, self.num_of_genes,
self.end_spread, self.population[i].id, child)
self.generations += 1
def generateCars(number):
global all_cars
all_cars += number
roads = ["NORTH","SOUTH","EAST","WEST"]
directions = ["LEFT","RIGHT","STRAIGHT"]
for i in range(1,number+1):
name = "Car" + str(i)
enter = random.choice(roads)
direction = random.choice(directions)
car = Car(name,enter,direction)
if enter=="NORTH":
northLane.append(car)
elif enter=="EAST":
eastLane.append(car)
elif enter=="WEST":
westLane.append(car)
elif enter=="SOUTH":
southLane.append(car)
else:
print("ERROR:","direction",direction,"does not exist.")
class MyTestCase(unittest.TestCase):
# вызывается перед каждым тестом
def setUp(self):
print('test setUp')
self.car = Car("car.jpg", "toyota", 756.7, 4)
# вызывается после каждого теста
def tearDown(self):
print('test tearDown')
# def test_something(self):
# print('run test: test_something')
# self.assertEqual(True, True)
def mocked_get_info(self):
return "???"
# заменяем метод get_info класса Car из модуля cars на свою заглушку
@patch('cars.Car.get_info', mocked_get_info)
def test_get_info(self):
print('run test: test_get_info')
self.assertEqual(self.car.get_info(), "???")
from cars import Car
bmv = Car('bmw', 90)
jugul = Car('jigul', 120)
print(jugul.car_ride())
print(bmv.marka)
print(getattr(bmv,"speed"))
if (hasattr(jugul, "speed")):
print('it actually rides')
else:
print("it is broken")
print(Car.__doc__) #получение документации
print(Car.__dict__)
#
# for attr in dir(bmv):
# if attr[0] == '_':
# print(attr)
# for item in bmv.__dict__:
# print(item, bmv.__dict__[item])
def run_episodes(self, num_episodes=20):
track = Track(50, self.window)
bg_cars = []
avg = 0
for i_episode in range(num_episodes):
self.createNewCars(bg_cars)
self.car = Car(250, 650, self.window)
self.execute = True
while self.execute:
keys = pygame.key.get_pressed()
self.window.fill((0, 255, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT or keys[pygame.K_0]:
pygame.quit()
if not self.car.ok and len(bg_cars) == 0:
self.execute = False
bg_cars = self.cleanUpCars(bg_cars)
while len(bg_cars) < 2 and self.car.ok:
randomno = random.randint(1, 50)
if randomno == 1:
new_car = BackgroundCars(
BG_CARS[random.randint(0, 5)], self.window
)
will_append = True
for cars in bg_cars:
if cars.collide(new_car):
will_append = False
break
if will_append:
bg_cars.append(new_car)
self.RANDOM_CARS_COUNT += 1
track.draw()
track.move()
for i in random.sample(
list(range(self.RANDOM_CARS_COUNT)), self.RANDOM_CARS_COUNT
):
bg_cars[i].draw()
bg_cars[i].move()
if self.car.ok:
state = self.get_state(bg_cars)
self.car.score += (
self.car.x if self.car.x < 250 else 500 - self.car.x
) // 50
self.car.score += 2
self.car.draw()
for cars in bg_cars:
if self.car.y + 100 < cars.y:
self.car.score += 50
if cars.collide(self.car):
self.car.ok = False
self.car.score //= 2
if self.car.x < 50 or self.car.x + self.car.width > 450:
self.car.score //= 2
self.car.ok = False
action = self.agent.select_action(state)
if action == 0:
self.car.left()
elif action == 1:
self.car.right()
else:
pass
reward = self.car.score
next_state = self.get_state(bg_cars) if self.car.ok else None
self.agent.memory.push(state, action, reward, next_state)
self.agent.learn()
self.display_text()
# self.clock.tick(60)
pygame.display.update()
while bg_cars:
for i in range(len(bg_cars)):
bg_cars[i].move()
bg_cars[i].draw()
bg_cars = self.cleanUpCars(bg_cars)
if i_episode % 10 == 0:
self.agent.target_brain.load_state_dict(self.agent.brain.state_dict())
print("\n\nAverage of last 10 episodes: ", avg / 10, "\n")
avg = 0
print("\nScore for episode", i_episode + 1, " ----- ", self.car.score)
avg += self.car.score
pygame.time.wait(100)
pygame.quit()
class Game:
RANDOM_CARS_COUNT = 0
def __init__(self):
pygame.init()
self.window = pygame.display.set_mode((500, 800))
pygame.display.set_caption("Racing AI")
self.clock = pygame.time.Clock()
self.execute = True
self.car = Car(250, 650, self.window)
self.agent = DQNAgent(inputs=4, n_actions=2)
self.episode_durations = []
self.update_agent = pygame.USEREVENT + 1
update_timer = 100
pygame.time.set_timer(self.update_agent, update_timer)
def cleanUpCars(self, bg_cars):
for c in bg_cars:
if c.y >= 800:
bg_cars.remove(c)
self.RANDOM_CARS_COUNT -= 1
return bg_cars
def createNewCars(self, bg_cars):
extra = len([car for car in bg_cars if not car.onScreen()])
while self.RANDOM_CARS_COUNT != MAX_CARS + extra:
new_car = BackgroundCars(BG_CARS[random.randint(0, 5)], self.window)
will_append = True
for cars in bg_cars:
if cars.collide(new_car) or self.RANDOM_CARS_COUNT == MAX_CARS + extra:
will_append = False
break
if will_append:
bg_cars.append(new_car)
self.RANDOM_CARS_COUNT += 1
return bg_cars
def get_state(self, bg_cars):
state = []
for car in bg_cars:
state.append(car.x / 500)
state.append(self.car.x / 500)
state.append((bg_cars[0].y - bg_cars[1].y) / 800)
return state
def run_episodes(self, num_episodes=20):
track = Track(50, self.window)
bg_cars = []
avg = 0
for i_episode in range(num_episodes):
self.createNewCars(bg_cars)
self.car = Car(250, 650, self.window)
self.execute = True
while self.execute:
keys = pygame.key.get_pressed()
self.window.fill((0, 255, 0))
for event in pygame.event.get():
if event.type == pygame.QUIT or keys[pygame.K_0]:
pygame.quit()
if not self.car.ok and len(bg_cars) == 0:
self.execute = False
bg_cars = self.cleanUpCars(bg_cars)
while len(bg_cars) < 2 and self.car.ok:
randomno = random.randint(1, 50)
if randomno == 1:
new_car = BackgroundCars(
BG_CARS[random.randint(0, 5)], self.window
)
will_append = True
for cars in bg_cars:
if cars.collide(new_car):
will_append = False
break
if will_append:
bg_cars.append(new_car)
self.RANDOM_CARS_COUNT += 1
track.draw()
track.move()
for i in random.sample(
list(range(self.RANDOM_CARS_COUNT)), self.RANDOM_CARS_COUNT
):
bg_cars[i].draw()
bg_cars[i].move()
if self.car.ok:
state = self.get_state(bg_cars)
self.car.score += (
self.car.x if self.car.x < 250 else 500 - self.car.x
) // 50
self.car.score += 2
self.car.draw()
for cars in bg_cars:
if self.car.y + 100 < cars.y:
self.car.score += 50
if cars.collide(self.car):
self.car.ok = False
self.car.score //= 2
if self.car.x < 50 or self.car.x + self.car.width > 450:
self.car.score //= 2
self.car.ok = False
action = self.agent.select_action(state)
if action == 0:
self.car.left()
elif action == 1:
self.car.right()
else:
pass
reward = self.car.score
next_state = self.get_state(bg_cars) if self.car.ok else None
self.agent.memory.push(state, action, reward, next_state)
self.agent.learn()
self.display_text()
# self.clock.tick(60)
pygame.display.update()
while bg_cars:
for i in range(len(bg_cars)):
bg_cars[i].move()
bg_cars[i].draw()
bg_cars = self.cleanUpCars(bg_cars)
if i_episode % 10 == 0:
self.agent.target_brain.load_state_dict(self.agent.brain.state_dict())
print("\n\nAverage of last 10 episodes: ", avg / 10, "\n")
avg = 0
print("\nScore for episode", i_episode + 1, " ----- ", self.car.score)
avg += self.car.score
pygame.time.wait(100)
pygame.quit()
def display_text(self):
font = pygame.font.SysFont("freesansbold", 32)
text = font.render(
" Score: " + str(self.car.score) + " ", True, (255, 0, 0), (0, 0, 0)
)
textRect = text.get_rect()
textRect.center = (400, 30)
self.window.blit(text, textRect)
# 04/03/2021 This file is for executing the cars.py classes
# Execution
# drive() we will not have an access to this function name yet
from cars import Car
mycar = Car("BMW", "530xi", "black") # Car is the class,
yourcar = Car("Lexus", "Lexus IS", "silver")
mycar.drive()
mycar.set_odometer_reader(50)
mycar.get_description()
yourcar.do_something()
mycar.get_description()
print("***************************")
yourcar.get_description()
yourcar.drive()
yourcar.set_odometer_reader(30)
yourcar.get_description()
## 04/03/2021
print("___Electric car instances______")
class ElecricCar(Car):
def __init__(self, brand, model, color):
super().__init__(brand, model, color)
self.battery_size = 60
#导入类
from cars import Car
my_new_car = Car('audi','a4','2016')
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
#导入多个类
from cars import ElectricCar,Car
my_tesla = ElectricCar('tesla','model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
#导入一个模块
import cars
my_beetle =cars.Car('volkswagen','beetle',2016)
print(my_beetle.get_descriptive_name())
my_tesla = cars.Car('tesla','roadster',2016)
class CarTest(unittest.TestCase):
"""Car klassini tekshirish uchun test"""
def setUp(self):
make = "GM"
self.model = "Malibu"
year = 2020
self.price = 40000
self.km = 10000
self.avto1 = Car(make, self.model, year)
self.avto2 = Car(make, self.model, year, price=self.price)
def test_create(self):
# Qiymatlar mavjudligini assertIsNotNone metodi bilan tekshiramiz
self.assertIsNotNone(self.avto1.make)
self.assertIsNotNone(self.avto1.model)
self.assertEqual(self.model, self.avto1.model)
self.assertIsNotNone(self.avto1.year)
# Qiymat mavjud emasligini assertIsNone metodi bilan tekshiramiz
self.assertIsNone(self.avto1.price)
# Qiymat tengligini assertEquals metodi bilan tekshiramiz
self.assertEqual(0, self.avto1.get_km())
# avto2 narhini tekshiramiz
self.assertEqual(self.price, self.avto2.price)
def test_set_price(self):
new_price = 45000
self.avto2.set_price(new_price)
self.assertEqual(new_price, self.avto2.price)
def test_add_km(self):
#1 Musbat qiymat berib ko'ramiz
self.avto1.add_km(self.km)
self.assertEqual(self.km, self.avto1.get_km())
self.avto1.add_km(5000)
self.assertEqual(15000, self.avto1.get_km())
#2 Manfiy qiymat berib ko'ramiz
new_km = -5000
try:
self.avto1.add_km(new_km)
except ValueError as error:
self.assertEqual(type(error), ValueError)
import random
from turtle import Screen
from score import Score
from cars import Car
from player import Player
screen = Screen()
screen.setup(600,600)
screen.tracer(0)
player=Player()
screen.listen()
screen.onkey(player.move_up, "Up")
game_on=True
cars=Car()
score=Score()
while game_on:
time.sleep(0.1)
if player.ycor() >= 280:
player.begin()
cars.speed_up()
score.level_up()
for car in cars.all_cars:
if car.distance(player)<=20:
score.end()
game_on=False
from turtle import Screen
from player import Player
from scoreboard import Scoreboard
from cars import Car
import time
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("white")
screen.tracer(0)
player = Player()
scoreboard = Scoreboard()
loop_count = 0
speed = 0.2
car = Car()
all_cars = [car]
screen.listen()
screen.onkey(player.move_forward, "Up")
screen.onkey(player.move_backward, "Down")
game_is_on = True
while game_is_on:
time.sleep(speed)
loop_count += 1
screen.update()
for item in all_cars:
item.move()
if item.xcor() - 30 < player.xcor() < item.xcor() + 30 and item.ycor(
) - 20 < player.ycor() < item.ycor() + 20:
for row in data:
for item in row:
print(item, end=" ")
print()
# functions
def draw(color, x, y):
pygame.draw.rect(screen, color, ((x * STEP, y * STEP), (STEP, STEP)))
# cars
audi = Car("Ауди", car_fuel=100)
# game loop
while True:
# keys
for i in pygame.event.get():
if i.type == pygame.QUIT:
exit()
elif i.type == pygame.KEYDOWN:
if i.key == pygame.K_UP:
audi.move_up(1)
elif i.key == pygame.K_RIGHT:
audi.move_right(1)
def test_car_type(self):
koenigsegg = Car('Koenigsegg', 'Agera R')
self.assertTrue(koenigsegg.is_saloon(),
msg='The car type should be saloon if it is not a trailer')
