def test_can_change_lane_when_alone(self):
car1 = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_close_to_traffic_lights(self):
car1 = Car(98, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_close_to_traffic_lights(self):
car1 = Car(98, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_can_change_lane_when_alone(self):
car1 = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_shouldnt_change_lane_to_go_faster_when_nothing(self):
car1 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_cant_change_lane_when_car_slightly_in_front(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(25, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_car_slightly_in_front(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(25, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_shouldnt_change_lane_to_go_faster_when_nothing(self):
car1 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_can_change_lane_when_cars_around_but_far(self):
car1 = Car(50, 0, 0, 10, 0)
car2 = Car(20, 0, 0, 10, 0)
car3 = Car(70, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
lane2.add_car(car3)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_can_change_lane_when_cars_around_but_far(self):
car1 = Car(50, 0, 0, 10, 0)
car2 = Car(20, 0, 0, 10, 0)
car3 = Car(70, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
lane2.add_car(car3)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_advance(self):
for i in range(1, 99):
test_car = Car(i, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car, lane, lanes, lights, 30, 0.1)
self.assertTrue(test_car.position < 100,
'Car starting at %d fail' % i)
def test_advance(self):
for i in range(1, 99):
test_car = Car(i, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car, lane, lanes, lights, 30, 0.1)
self.assertTrue(test_car.position < 100,
'Car starting at %d fail' % i)
def test_should_change_lane_to_go_to_no_car_lane(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(30, 0, 0, 10, 0)
car3 = Car(60, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane1.add_car(car3)
lane0.add_car(car2)
light = TrafficLight(100)
self.assertEquals(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]), lane2)
def test_should_change_lane_to_go_to_no_car_lane(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(30, 0, 0, 10, 0)
car3 = Car(60, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane1.add_car(car3)
lane0.add_car(car2)
light = TrafficLight(100)
self.assertEquals(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]),
lane2)
def test_advance_with_car_in_front(self):
for i in range (1, 80):
test_car_1 = Car(i, 0, 0, 0, 0)
test_car_2 = Car(i + 19, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car_1)
lane.add_car(test_car_2)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car_1, lane, lanes, lights, 30, 0.1)
control.advance(test_car_2, lane, lanes, lights, 30, 0.1)
self.assertTrue(test_car_1.position < 100,
'First car at %d fail, pos(car1) = %f, pos(car2) = %f'
%(i, test_car_1.position, test_car_2.position))
self.assertTrue(test_car_2.position < 100,
'Second car at %d fails' % (i + 19))
self.assertTrue(test_car_1.position <= control.rear(
test_car_2, test_car_1.speed),
'First car ended up further than expected'
)
def test_advance_with_car_in_front(self):
for i in range(1, 80):
test_car_1 = Car(i, 0, 0, 0, 0)
test_car_2 = Car(i + 19, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car_1)
lane.add_car(test_car_2)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car_1, lane, lanes, lights, 30, 0.1)
control.advance(test_car_2, lane, lanes, lights, 30, 0.1)
self.assertTrue(
test_car_1.position < 100,
'First car at %d fail, pos(car1) = %f, pos(car2) = %f' %
(i, test_car_1.position, test_car_2.position))
self.assertTrue(test_car_2.position < 100,
'Second car at %d fails' % (i + 19))
self.assertTrue(
test_car_1.position <= control.rear(test_car_2,
test_car_1.speed),
'First car ended up further than expected')
def test_shouldnt_change_lane_when_current_lane_is_fastest(self):
car0 = Car(30, 0, 0, 10, 0)
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(45, 0, 0, 10, 0)
car3 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane0.add_car(car0)
lane1.add_car(car1)
lane1.add_car(car3)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_shouldnt_change_lane_when_current_lane_is_fastest(self):
car0 = Car(30, 0, 0, 10, 0)
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(45, 0, 0, 10, 0)
car3 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane0.add_car(car0)
lane1.add_car(car1)
lane1.add_car(car3)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
class ControlTest(unittest.TestCase):
def setUp(self):
self.car = Car(200, 0, 0, 0, 0)
self.lane = Lane()
self.lane.add_car(self.car)
def test_next_in_set(self):
self.assertEquals(
control._next_in_set(3, [1, 2, 3, 4, 5], key = lambda x: x), 3
)
self.assertEquals(
control._next_in_set(3, [1, 2, 3.5, 4, 5], key = lambda x: x), 3.5
)
def test_prev_in_set(self):
self.assertEquals(
control._prev_in_set(3, [1, 2, 3, 4, 5], key = lambda x: x), 3
)
self.assertEquals(
control._prev_in_set(3, [1, 2.5, 3.5, 4, 5], key = lambda x: x), 2.5
)
def test_cant_advance_on_traffic_light(self):
red_light = TrafficLight(200, initial_state='Red')
self.assertFalse(
control.can_advance(self.car, self.lane, [self.lane], [red_light], 0)
)
def test_can_advance_on_green(self):
light = TrafficLight(200)
self.assertTrue(
control.can_advance(self.car, self.lane, [self.lane], [light], 0)
)
def test_car_cant_advance_due_to_traffic(self):
light = TrafficLight(200)
other_car = Car(200 + Car.length, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertFalse(
control.can_advance(self.car, self.lane, [self.lane], [light], 0)
)
# Cleanup
self.lane.remove_car(other_car)
def test_get_next_car_before_next_traffic_light_returns_car(self):
light = TrafficLight(100)
self.car.position = 20
other_car = Car(80, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertEquals(
control.get_next_car_before_next_traffic_light(
self.car, self.lane, [light]
), other_car
)
self.lane.remove_car(other_car)
self.car.position = 200
def test_get_next_car_before_next_traffic_light_returns_none(self):
light = TrafficLight(100)
self.car.position = 20
other_car = Car(120, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertFalse(
control.get_next_car_before_next_traffic_light(
self.car, self.lane, [light]
)
)
self.lane.remove_car(other_car)
self.car.position = 200
def test_get_next_car_before_next_traffic_light_when_car_on_light(self):
light = TrafficLight(200)
other_car = Car(220, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertFalse(
control.get_next_car_before_next_traffic_light(
self.car, self.lane, [light]
)
)
self.lane.remove_car(other_car)
def test_solve_quadratic_equation_with_one_negative_solution(self):
self.assertEquals(control.solve_quadratic_equation(1, -3, -10), 5)
def test_solve_quadratic_equation_with_one_solution(self):
self.assertEquals(control.solve_quadratic_equation(1, -8, 16), 4)
def test_solve_quadratic_equation_with_two_positive_solutions(self):
self.assertEquals(control.solve_quadratic_equation(1, -7, 10), 2)
def test_get_target_time_without_reaching_max_speed(self):
test_car = Car(0, 0, 0, 5, 0)
self.assertTrue(
abs(control.get_target_time(test_car, 10) - 1.6108) < 0.0001
)
def test_get_target_time_reaching_max_speed(self):
test_car = Car(0, 0, 0, 5, 0)
self.assertTrue(
abs(control.get_target_time(test_car, 100) -
(20.0 / 9 + 200.0 / 3) < 0.0001)
)
def test_advance(self):
for i in range(1, 99):
test_car = Car(i, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car, lane, lanes, lights, 30, 0.1)
self.assertTrue(test_car.position < 100,
'Car starting at %d fail' % i)
def test_advance_with_car_in_front(self):
for i in range (1, 80):
test_car_1 = Car(i, 0, 0, 0, 0)
test_car_2 = Car(i + 19, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car_1)
lane.add_car(test_car_2)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car_1, lane, lanes, lights, 30, 0.1)
control.advance(test_car_2, lane, lanes, lights, 30, 0.1)
self.assertTrue(test_car_1.position < 100,
'First car at %d fail, pos(car1) = %f, pos(car2) = %f'
%(i, test_car_1.position, test_car_2.position))
self.assertTrue(test_car_2.position < 100,
'Second car at %d fails' % (i + 19))
self.assertTrue(test_car_1.position <= control.rear(
test_car_2, test_car_1.speed),
'First car ended up further than expected'
)
def test_cant_change_lane_when_car_beside(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_car_slightly_behind(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(15, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_car_slightly_in_front(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(25, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_close_to_traffic_lights(self):
car1 = Car(98, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_to_lane_with_opposite_direction(self):
car = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane('SOUTH')
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car, lane1, lane2, [light]))
def test_can_change_lane_when_alone(self):
car1 = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_can_change_lane_when_cars_around_but_far(self):
car1 = Car(50, 0, 0, 10, 0)
car2 = Car(20, 0, 0, 10, 0)
car3 = Car(70, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
lane2.add_car(car3)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_shouldnt_change_lane_to_go_faster_when_nothing(self):
car1 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_shouldnt_change_lane_to_go_faster_when_no_cars_in_front(self):
car1 = Car(10, 0, 0, 10, 0)
car0 = Car(50, 0, 0, 10, 0)
car2 = Car(40, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane0.add_car(car0)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_should_change_lane_to_go_to_faster_lane(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(30, 0, 0, 10, 0)
car3 = Car(40, 0, 0, 10, 0)
car4 = Car(35, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane1.add_car(car4)
lane0.add_car(car2)
lane2.add_car(car3)
light = TrafficLight(100)
self.assertEquals(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]), lane2)
def test_should_change_lane_to_go_to_no_car_lane(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(30, 0, 0, 10, 0)
car3 = Car(60, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane1.add_car(car3)
lane0.add_car(car2)
light = TrafficLight(100)
self.assertEquals(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]), lane2)
def test_shouldnt_change_lane_when_cant_change_lane(self):
car0 = Car(18, 0, 0, 10, 0)
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(25, 0, 0, 10, 0)
car3 = Car(23, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane0.add_car(car0)
lane1.add_car(car1)
lane1.add_car(car3)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_shouldnt_change_lane_when_current_lane_is_fastest(self):
car0 = Car(30, 0, 0, 10, 0)
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(45, 0, 0, 10, 0)
car3 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane0.add_car(car0)
lane1.add_car(car1)
lane1.add_car(car3)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_bus_arrived_at_stop_at_full_capacity(self):
lane = Lane()
stop = BusStop(lane, 30, 10)
line = BusLine([stop], 0, 500)
bus = Bus(line, 10, 100)
control.bus_stop(bus, stop)
self.assertEquals(bus.people_carried, 100)
self.assertEquals(stop.people, 10)
def test_bus_arrived_and_people_were_left_at_stop(self):
lane = Lane()
stop = BusStop(lane, 30, 10)
line = BusLine([stop], 0, 500)
bus = Bus(line, 10, 93)
control.bus_stop(bus, stop)
self.assertEquals(bus.people_carried, 100)
self.assertEquals(stop.people, 3)
def test_bus_arrived_and_everybody_got_on_the_bus(self):
lane = Lane()
stop = BusStop(lane, 30, 10)
line = BusLine([stop], 0, 500)
bus = Bus(line, 10, 10)
control.bus_stop(bus, stop)
self.assertEquals(bus.people_carried, 20)
self.assertEquals(stop.people, 0)
def test_appear_cars_between_two_lanes(self):
lanes = [Lane(), Lane()]
lights = [TrafficLight(100)]
def test_get_target_lanes(self):
lanes = [Lane(), Lane(), Lane(), Lane(), Lane(), Lane(), Lane(), Lane()]
self.assertEquals(control._get_target_lanes(lanes[3], lanes, 4, 4),
[lanes[2], None])
self.assertEquals(control._get_target_lanes(lanes[0], lanes, 4, 4),
[None, lanes[1]])
self.assertEquals(control._get_target_lanes(lanes[2], lanes, 4, 4),
[lanes[1], lanes[3]])
self.assertEquals(control._get_target_lanes(lanes[4], lanes, 4, 4),
[None, lanes[5]])
self.assertEquals(control._get_target_lanes(lanes[7], lanes, 4, 4),
[lanes[6], None])
class ControlTest(unittest.TestCase):
def setUp(self):
self.car = Car(200, 0, 0, 0, 0)
self.lane = Lane()
self.lane.add_car(self.car)
def test_next_in_set(self):
self.assertEquals(
control._next_in_set(3, [1, 2, 3, 4, 5], key=lambda x: x), 3)
self.assertEquals(
control._next_in_set(3, [1, 2, 3.5, 4, 5], key=lambda x: x), 3.5)
def test_prev_in_set(self):
self.assertEquals(
control._prev_in_set(3, [1, 2, 3, 4, 5], key=lambda x: x), 3)
self.assertEquals(
control._prev_in_set(3, [1, 2.5, 3.5, 4, 5], key=lambda x: x), 2.5)
def test_cant_advance_on_traffic_light(self):
red_light = TrafficLight(200, initial_state='Red')
self.assertFalse(
control.can_advance(self.car, self.lane, [self.lane], [red_light],
0))
def test_can_advance_on_green(self):
light = TrafficLight(200)
self.assertTrue(
control.can_advance(self.car, self.lane, [self.lane], [light], 0))
def test_car_cant_advance_due_to_traffic(self):
light = TrafficLight(200)
other_car = Car(200 + Car.length, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertFalse(
control.can_advance(self.car, self.lane, [self.lane], [light], 0))
# Cleanup
self.lane.remove_car(other_car)
def test_get_next_car_before_next_traffic_light_returns_car(self):
light = TrafficLight(100)
self.car.position = 20
other_car = Car(80, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertEquals(
control.get_next_car_before_next_traffic_light(
self.car, self.lane, [light]), other_car)
self.lane.remove_car(other_car)
self.car.position = 200
def test_get_next_car_before_next_traffic_light_returns_none(self):
light = TrafficLight(100)
self.car.position = 20
other_car = Car(120, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertFalse(
control.get_next_car_before_next_traffic_light(
self.car, self.lane, [light]))
self.lane.remove_car(other_car)
self.car.position = 200
def test_get_next_car_before_next_traffic_light_when_car_on_light(self):
light = TrafficLight(200)
other_car = Car(220, 0, 0, 0, 0)
self.lane.add_car(other_car)
self.assertFalse(
control.get_next_car_before_next_traffic_light(
self.car, self.lane, [light]))
self.lane.remove_car(other_car)
def test_solve_quadratic_equation_with_one_negative_solution(self):
self.assertEquals(control.solve_quadratic_equation(1, -3, -10), 5)
def test_solve_quadratic_equation_with_one_solution(self):
self.assertEquals(control.solve_quadratic_equation(1, -8, 16), 4)
def test_solve_quadratic_equation_with_two_positive_solutions(self):
self.assertEquals(control.solve_quadratic_equation(1, -7, 10), 2)
def test_get_target_time_without_reaching_max_speed(self):
test_car = Car(0, 0, 0, 5, 0)
self.assertTrue(
abs(control.get_target_time(test_car, 10) - 1.6108) < 0.0001)
def test_get_target_time_reaching_max_speed(self):
test_car = Car(0, 0, 0, 5, 0)
self.assertTrue(
abs(
control.get_target_time(test_car, 100) -
(20.0 / 9 + 200.0 / 3) < 0.0001))
def test_advance(self):
for i in range(1, 99):
test_car = Car(i, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car, lane, lanes, lights, 30, 0.1)
self.assertTrue(test_car.position < 100,
'Car starting at %d fail' % i)
def test_advance_with_car_in_front(self):
for i in range(1, 80):
test_car_1 = Car(i, 0, 0, 0, 0)
test_car_2 = Car(i + 19, 0, 0, 0, 0)
lane = Lane()
lanes = [lane]
lane.add_car(test_car_1)
lane.add_car(test_car_2)
lights = [TrafficLight(100)]
for j in range(200):
control.advance(test_car_1, lane, lanes, lights, 30, 0.1)
control.advance(test_car_2, lane, lanes, lights, 30, 0.1)
self.assertTrue(
test_car_1.position < 100,
'First car at %d fail, pos(car1) = %f, pos(car2) = %f' %
(i, test_car_1.position, test_car_2.position))
self.assertTrue(test_car_2.position < 100,
'Second car at %d fails' % (i + 19))
self.assertTrue(
test_car_1.position <= control.rear(test_car_2,
test_car_1.speed),
'First car ended up further than expected')
def test_cant_change_lane_when_car_beside(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_car_slightly_behind(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(15, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_car_slightly_in_front(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(25, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_lane_when_close_to_traffic_lights(self):
car1 = Car(98, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car1, lane1, lane2, [light]))
def test_cant_change_to_lane_with_opposite_direction(self):
car = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane('SOUTH')
light = TrafficLight(100)
self.assertFalse(control.can_change_lane(car, lane1, lane2, [light]))
def test_can_change_lane_when_alone(self):
car1 = Car(20, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_can_change_lane_when_cars_around_but_far(self):
car1 = Car(50, 0, 0, 10, 0)
car2 = Car(20, 0, 0, 10, 0)
car3 = Car(70, 0, 0, 10, 0)
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane2.add_car(car2)
lane2.add_car(car3)
light = TrafficLight(100)
self.assertTrue(control.can_change_lane(car1, lane1, lane2, [light]))
def test_shouldnt_change_lane_to_go_faster_when_nothing(self):
car1 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
light = TrafficLight(100)
self.assertFalse(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_shouldnt_change_lane_to_go_faster_when_no_cars_in_front(self):
car1 = Car(10, 0, 0, 10, 0)
car0 = Car(50, 0, 0, 10, 0)
car2 = Car(40, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane0.add_car(car0)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_should_change_lane_to_go_to_faster_lane(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(30, 0, 0, 10, 0)
car3 = Car(40, 0, 0, 10, 0)
car4 = Car(35, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane1.add_car(car4)
lane0.add_car(car2)
lane2.add_car(car3)
light = TrafficLight(100)
self.assertEquals(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]),
lane2)
def test_should_change_lane_to_go_to_no_car_lane(self):
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(30, 0, 0, 10, 0)
car3 = Car(60, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane1.add_car(car1)
lane1.add_car(car3)
lane0.add_car(car2)
light = TrafficLight(100)
self.assertEquals(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]),
lane2)
def test_shouldnt_change_lane_when_cant_change_lane(self):
car0 = Car(18, 0, 0, 10, 0)
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(25, 0, 0, 10, 0)
car3 = Car(23, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane0.add_car(car0)
lane1.add_car(car1)
lane1.add_car(car3)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_shouldnt_change_lane_when_current_lane_is_fastest(self):
car0 = Car(30, 0, 0, 10, 0)
car1 = Car(20, 0, 0, 10, 0)
car2 = Car(45, 0, 0, 10, 0)
car3 = Car(50, 0, 0, 10, 0)
lane0 = Lane()
lane1 = Lane()
lane2 = Lane()
lane0.add_car(car0)
lane1.add_car(car1)
lane1.add_car(car3)
lane2.add_car(car2)
light = TrafficLight(100)
self.assertFalse(
control.should_change_lane_to_move_faster(car1, lane1,
[lane0, lane2], [light]))
def test_bus_arrived_at_stop_at_full_capacity(self):
lane = Lane()
stop = BusStop(lane, 30, 10)
line = BusLine([stop], 0, 500)
bus = Bus(line, 10, 100)
control.bus_stop(bus, stop)
self.assertEquals(bus.people_carried, 100)
self.assertEquals(stop.people, 10)
def test_bus_arrived_and_people_were_left_at_stop(self):
lane = Lane()
stop = BusStop(lane, 30, 10)
line = BusLine([stop], 0, 500)
bus = Bus(line, 10, 93)
control.bus_stop(bus, stop)
self.assertEquals(bus.people_carried, 100)
self.assertEquals(stop.people, 3)
def test_bus_arrived_and_everybody_got_on_the_bus(self):
lane = Lane()
stop = BusStop(lane, 30, 10)
line = BusLine([stop], 0, 500)
bus = Bus(line, 10, 10)
control.bus_stop(bus, stop)
self.assertEquals(bus.people_carried, 20)
self.assertEquals(stop.people, 0)
def test_appear_cars_between_two_lanes(self):
lanes = [Lane(), Lane()]
lights = [TrafficLight(100)]
def test_get_target_lanes(self):
lanes = [
Lane(),
Lane(),
Lane(),
Lane(),
Lane(),
Lane(),
Lane(),
Lane()
]
self.assertEquals(control._get_target_lanes(lanes[3], lanes, 4, 4),
[lanes[2], None])
self.assertEquals(control._get_target_lanes(lanes[0], lanes, 4, 4),
[None, lanes[1]])
self.assertEquals(control._get_target_lanes(lanes[2], lanes, 4, 4),
[lanes[1], lanes[3]])
self.assertEquals(control._get_target_lanes(lanes[4], lanes, 4, 4),
[None, lanes[5]])
self.assertEquals(control._get_target_lanes(lanes[7], lanes, 4, 4),
[lanes[6], None])
class Simulator():
time_steps_per_hours = 36000
# short refers to closest exit and long to exit furthest away
time_car_drive_short = 30
time_car_drive_straight = 45
time_car_drive_long = 60
# it takes 50% less time to pass if the car in front is moving
time_rolling_multiplier = 0.5
time_between_rolling = 5
# not occupied if 0
occupied_upper_left = 0
occupied_upper_right = 0
occupied_lower_left = 0
occupied_lower_right = 0
previous_green = Direction.SOUTH
def __init__(self, *args, **kwargs):
self.south = Lane("south")
self.north = Lane("north")
self.west = Lane("west")
self.east = Lane("east")
self.traffic_probability = self.fit_curve(False)
self.time = 0
#self.setup_GUI()
def setup_GUI(self):
self.root = tkinter.Tk()
self.ul = tkinter.IntVar()
self.ul.set(0)
self.ur = tkinter.IntVar()
self.ur.set(0)
self.ll = tkinter.IntVar()
self.ll.set(0)
self.lr = tkinter.IntVar()
self.lr.set(0)
l = tkinter.Label(self.root, textvariable="Testing")
l.pack()
#tkinter.Label(self.root, textvariable=self.ul).grid(row = 0, column=0)
#tkinter.Label(self.root, textvariable=self.ur).grid(row = 0, column=1)
#tkinter.Label(self.root, textvariable=self.ll).grid(row = 1, column=0)
#tkinter.Label(self.root, textvariable=self.lr).grid(row = 1, column=1)
def set_values(self, ul, ur, ll, lr):
self.ul.set(ul)
self.ur.set(ur)
self.ll.set(ll)
self.lr.set(lr)
def fit_curve(self, graph):
"""
Fit a curve to traffic data points.
Parameters
----------
graph : bool
show curve graph or not
Returns
-------
function
function that calculates traffic probability
"""
points = np.array([
(0, 50.), (1, 40), (2, 30), (3, 25), (4, 30), (5, 35), (6, 60),
(7, 150), (8, 500), (9, 520), (10, 600), (11, 600), (12, 475),
(13, 380), (14, 350), (15, 400), (16, 500), (17, 550), (18, 550),
(19, 350), (20, 275), (21, 190), (22, 150), (23, 125), (24, 90)
])
points = self.normalize_tuple_y(points)
# get x and y vectors
x = points[:, 0]
y = points[:, 1]
# calculate polynomial
z = np.polyfit(x, y, 11)
f = np.poly1d(z)
# calculate new x's and y's
if (graph):
x_new = np.linspace(x[0], x[-1], 50)
y_new = f(x_new)
plt.plot(x, y, 'o', x_new, y_new)
plt.xlim([x[0] - 1, x[-1] + 1])
plt.show()
return f
def normalize_tuple_y(self, tuple_list):
"""
Normalize the second value (y value) in the tuple.
Parameters
----------
tuple_list : list
list of tuples
Returns
-------
list
list of y normalized tuples
"""
max = 0
for element in tuple_list:
if (element[1] > max):
max = element[1]
for element in tuple_list:
element[1] = element[1] / max
return tuple_list
def stochastic_add(self, hour):
"""
Add car to a random lane following traffic probability function.
Parameters
----------
hour : float
hour of day
"""
r_number = random.uniform(0, 1)
if (r_number <= self.traffic_probability(hour)):
r_number = randint(0, 3)
if (r_number == 0):
self.west.add_car(
Car(self.get_random_direction(Direction.WEST), self.time))
elif (r_number == 1):
self.south.add_car(
Car(self.get_random_direction(Direction.SOUTH), self.time))
elif (r_number == 2):
self.north.add_car(
Car(self.get_random_direction(Direction.NORTH), self.time))
elif (r_number == 3):
self.east.add_car(
Car(self.get_random_direction(Direction.EAST), self.time))
def add_direction(self, direction):
if (direction == Direction.WEST):
self.west.add_car(
Car(self.get_random_direction(Direction.WEST), self.time))
#print('Car added west')
elif (direction == Direction.SOUTH):
self.south.add_car(
Car(self.get_random_direction(Direction.SOUTH), self.time))
#print('Car added south')
elif (direction == Direction.NORTH):
self.north.add_car(
Car(self.get_random_direction(Direction.NORTH), self.time))
#print('Car added north')
elif (direction == Direction.EAST):
self.east.add_car(
Car(self.get_random_direction(Direction.EAST), self.time))
#print('Car added east')
def get_random_direction(self, direction_from):
r_number = randint(0, 2)
if (direction_from == Direction.NORTH):
if (r_number == 0):
return Direction.SOUTH
elif (r_number == 1):
return Direction.EAST
elif (r_number == 2):
return Direction.WEST
elif (direction_from == Direction.SOUTH):
if (r_number == 0):
return Direction.NORTH
elif (r_number == 1):
return Direction.EAST
elif (r_number == 2):
return Direction.WEST
elif (direction_from == Direction.EAST):
if (r_number == 0):
return Direction.SOUTH
elif (r_number == 1):
return Direction.NORTH
elif (r_number == 2):
return Direction.WEST
elif (direction_from == Direction.WEST):
if (r_number == 0):
return Direction.SOUTH
elif (r_number == 1):
return Direction.EAST
elif (r_number == 2):
return Direction.NORTH
def green(self, lane):
# TODO check occupancy can be false if from the same lane
# TODO A function that update_occupancy(from, to) w/ time variables
if (lane == Direction.NORTH):
car = self.north.peek_car()
# car can go
#print(self.previous_green)
#print(self.previous_green == lane)
#print(self.check_occupancy(lane, car.direction))
if car != None and ((self.check_occupancy(lane, car.direction)
or self.previous_green == lane)):
self.set_occupancy(lane, car.direction,
self.previous_green == lane)
if (self.previous_green == lane):
if (self.north.time_since_green >=
self.time_between_rolling):
self.north.green()
self.previous_green = lane
else:
self.north.green()
self.previous_green = lane
elif (lane == Direction.SOUTH):
car = self.south.peek_car()
# car can go
if (car != None and (self.check_occupancy(lane, car.direction)
or self.previous_green == lane)):
self.set_occupancy(lane, car.direction,
self.previous_green == lane)
if (self.previous_green == lane):
if (self.south.time_since_green >=
self.time_between_rolling):
self.south.green()
self.previous_green = lane
else:
self.south.green()
self.previous_green = lane
elif (lane == Direction.WEST):
car = self.west.peek_car()
# car can go
if (car != None and (self.check_occupancy(lane, car.direction)
or self.previous_green == lane)):
self.set_occupancy(lane, car.direction,
self.previous_green == lane)
if (self.previous_green == lane):
if (self.west.time_since_green >=
self.time_between_rolling):
self.west.green()
self.previous_green = lane
else:
self.west.green()
self.previous_green = lane
elif (lane == Direction.EAST):
car = self.east.peek_car()
# car can go
if (car != None and (self.check_occupancy(lane, car.direction)
or self.previous_green == lane)):
self.set_occupancy(lane, car.direction,
self.previous_green == lane)
if (self.previous_green == lane):
if (self.east.time_since_green >=
self.time_between_rolling):
self.east.green()
self.previous_green = lane
else:
self.east.green()
self.previous_green = lane
def check_occupancy(self, direction_from, direction_to):
if (direction_from == Direction.NORTH):
if (direction_to == Direction.WEST):
return self.occupied_upper_left == 0
elif (direction_to == Direction.EAST):
return (self.occupied_upper_left == 0
and self.occupied_lower_left == 0
and self.occupied_lower_right == 0)
elif (direction_to == Direction.SOUTH):
return (self.occupied_upper_left == 0
and self.occupied_lower_left == 0)
elif (direction_from == Direction.SOUTH):
if (direction_to == Direction.WEST):
return (self.occupied_upper_left == 0
and self.occupied_upper_right == 0
and self.occupied_lower_right == 0)
elif (direction_to == Direction.EAST):
return self.occupied_lower_right == 0
elif (direction_to == Direction.NORTH):
return (self.occupied_upper_right == 0
and self.occupied_lower_right == 0)
elif (direction_from == Direction.WEST):
if (direction_to == Direction.NORTH):
return (self.occupied_lower_left == 0
and self.occupied_lower_right == 0
and self.occupied_upper_right == 0)
elif (direction_to == Direction.SOUTH):
return self.occupied_lower_left == 0
elif (direction_to == Direction.EAST):
return (self.occupied_lower_left == 0
and self.occupied_lower_right == 0)
elif (direction_from == Direction.EAST):
if (direction_to == Direction.SOUTH):
return (self.occupied_upper_left == 0
and self.occupied_upper_right == 0
and self.occupied_lower_left == 0)
elif (direction_to == Direction.NORTH):
return self.occupied_upper_left == 0
elif (direction_to == Direction.WEST):
return (self.occupied_upper_left == 0
and self.occupied_upper_right == 0)
def set_occupancy(self, direction_from, direction_to, reduced):
multiplier = 1
if (reduced):
multiplier = self.time_rolling_multiplier
# literally puke, is there a neater way to do this?..
if (direction_from == Direction.NORTH):
if (direction_to == Direction.WEST):
if (self.time_car_drive_short * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_short * multiplier
elif (direction_to == Direction.EAST):
if (self.time_car_drive_long * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_lower_left):
self.occupied_lower_left = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_lower_right):
self.occupied_lower_right = self.time_car_drive_long * multiplier
elif (direction_to == Direction.SOUTH):
if (self.time_car_drive_straight * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_straight * multiplier
if (self.time_car_drive_straight * multiplier >
self.occupied_lower_left):
self.occupied_lower_left = self.time_car_drive_straight * multiplier
elif (direction_from == Direction.SOUTH):
if (direction_to == Direction.WEST):
if (self.time_car_drive_long * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_upper_right):
self.occupied_upper_right = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_lower_right):
self.occupied_lower_right = self.time_car_drive_long * multiplier
elif (direction_to == Direction.EAST):
if (self.time_car_drive_short * multiplier >
self.occupied_lower_right):
self.occupied_lower_right = self.time_car_drive_short * multiplier
elif (direction_to == Direction.NORTH):
if (self.time_car_drive_straight * multiplier >
self.occupied_upper_right):
self.occupied_upper_right = self.time_car_drive_straight * multiplier
if (self.time_car_drive_straight * multiplier >
self.occupied_lower_right):
self.occupied_lower_right = self.time_car_drive_straight * multiplier
elif (direction_from == Direction.WEST):
if (direction_to == Direction.NORTH):
if (self.time_car_drive_long * multiplier >
self.occupied_lower_left):
self.occupied_lower_left = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_lower_right):
self.occupied_lower_right = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_upper_right):
self.occupied_upper_right = self.time_car_drive_long * multiplier
elif (direction_to == Direction.SOUTH):
if (self.time_car_drive_short * multiplier >
self.occupied_lower_left):
self.occupied_lower_left = self.time_car_drive_short * multiplier
elif (direction_to == Direction.EAST):
if (self.time_car_drive_straight * multiplier >
self.occupied_lower_left):
self.occupied_lower_left = self.time_car_drive_straight * multiplier
if (self.time_car_drive_straight * multiplier >
self.occupied_lower_right):
self.occupied_lower_right = self.time_car_drive_straight * multiplier
elif (direction_from == Direction.EAST):
if (direction_to == Direction.SOUTH):
if (self.time_car_drive_long * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_upper_right):
self.occupied_upper_right = self.time_car_drive_long * multiplier
if (self.time_car_drive_long * multiplier >
self.occupied_lower_left):
self.occupied_lower_left = self.time_car_drive_long * multiplier
elif (direction_to == Direction.NORTH):
if (self.time_car_drive_short * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_short * multiplier
elif (direction_to == Direction.WEST):
if (self.time_car_drive_straight * multiplier >
self.occupied_upper_left):
self.occupied_upper_left = self.time_car_drive_straight * multiplier
if (self.time_car_drive_straight * multiplier >
self.occupied_upper_right):
self.occupied_upper_right = self.time_car_drive_straight * multiplier
def __str__(self):
string = '======================================================================'
string += '\nNorth: \n'
for car in self.north.get_cars():
string += car.__str__() + '\n'
string += '======================================================================'
string += '\nSouth: \n'
for car in self.south.get_cars():
string += car.__str__() + '\n'
string += '======================================================================'
string += '\nWest: \n'
for car in self.west.get_cars():
string += car.__str__() + '\n'
string += '======================================================================'
string += '\nEast: \n'
for car in self.east.get_cars():
string += car.__str__() + '\n'
string += '======================================================================'
return string
def run(self, scheduler):
count = 0
X = []
nY = []
sY = []
wY = []
eY = []
while (count < self.time_steps_per_hours * 24):
#time.sleep(2)
hour = count / self.time_steps_per_hours
#self.add_direction(Direction.SOUTH)
if (count % 20 == 0):
#self.stochastic_add(hour)
self.add_direction(Direction.SOUTH)
self.add_direction(Direction.NORTH)
self.add_direction(Direction.WEST)
self.add_direction(Direction.EAST)
pass
#self.green(Direction.SOUTH)
scheduler.schedule()
count += 1
# save statistics
X.append(hour)
nY.append(self.north.size())
sY.append(self.south.size())
wY.append(self.west.size())
eY.append(self.east.size())
"""
self.set_values(self.occupied_upper_left, self.occupied_upper_right,
self.occupied_lower_left, self.occupied_lower_right)
self.root.update_idletasks()
"""
# time passes
self.time += 1
if (self.occupied_upper_left > 0):
self.occupied_upper_left -= 1
if (self.occupied_upper_right > 0):
self.occupied_upper_right -= 1
if (self.occupied_lower_left > 0):
self.occupied_lower_left -= 1
if (self.occupied_lower_right > 0):
self.occupied_lower_right -= 1
self.north.update()
self.south.update()
self.west.update()
self.east.update()
#print('upper left: ' + str(self.occupied_upper_left))
#print('upper right: ' + str(self.occupied_upper_right))
#print('lower left: ' + str(self.occupied_lower_left))
#print('lower right: ' + str(self.occupied_lower_right))
plt.subplot(1, 1, 1)
plt.plot(X, nY, label='North')
plt.plot(X, sY, label='South')
plt.plot(X, wY, label='West')
plt.plot(X, eY, label='East')
plt.legend(loc='upper left')
plt.show()
class TrafficMap(ColorLayer):
def __init__(self):
super(TrafficMap, self).__init__(46, 139, 87, 255)
self.north_stop_line = None
self.east_stop_line = None
self.south_stop_line = None
self.west_stop_line = None
self.north_normal_button = Button("normal", "north", self)
self.east_normal_button = Button("normal", "east", self)
self.south_normal_button = Button("normal", "south", self)
self.west_normal_button = Button("normal", "west", self)
self.north_emergency_button = Button("emergency", "north", self)
self.east_emergency_button = Button("emergency", "east", self)
self.south_emergency_button = Button("emergency", "south", self)
self.west_emergency_button = Button("emergency", "west", self)
self.car_queue = []
self.from_north_light = TrafficLight("north")
self.from_east_light = TrafficLight("east")
self.from_south_light = TrafficLight("south")
self.from_west_light = TrafficLight("west")
self.from_north_light.push_handlers(self)
self.from_east_light.push_handlers(self)
self.from_south_light.push_handlers(self)
self.from_west_light.push_handlers(self)
self.north_lane = Lane(self, 'north')
self.south_lane = Lane(self, 'south')
self.east_lane = Lane(self, 'east')
self.west_lane = Lane(self, 'west')
self.central_occupied = 0
self.draw_road()
self.draw_button()
self.draw_light()
self.running_lane = "horizontal"
self.last_change_time = time.time()
pyglet.clock.schedule_interval(self.schedule, 0.1)
self.aging = False
def draw_road(self):
road_image_1 = image.create(200, 800, image.SolidColorImagePattern(color=(190, 190, 190, 255)))
road_image_2 = image.create(800, 200, image.SolidColorImagePattern(color=(190, 190, 190, 255)))
road_1 = Sprite(road_image_1, position=(400, 400))
road_2 = Sprite(road_image_2, position=(400, 400))
self.add(road_1)
self.add(road_2)
self.draw_line()
def draw_line(self):
line_1 = Line(start=(0, 400), end=(300, 400), color=(255, 215, 0, 255), stroke_width=5)
self.add(line_1)
line_2 = Line(start=(400, 800), end=(400, 500), color=(255, 215, 0, 255), stroke_width=5)
self.add(line_2)
line_3 = Line(start=(500, 400), end=(800, 400), color=(255, 215, 0, 255), stroke_width=5)
self.add(line_3)
line_4 = Line(start=(400, 300), end=(400, 0), color=(255, 215, 0, 255), stroke_width=5)
self.add(line_4)
self.north_stop_line = Line(start=(300, 500), end=(500, 500), color=(255, 255, 255, 255), stroke_width=5)
self.add(self.north_stop_line)
self.east_stop_line = Line(start=(500, 500), end=(500, 300), color=(255, 255, 255, 255), stroke_width=5)
self.add(self.east_stop_line)
self.south_stop_line = Line(start=(500, 300), end=(300, 300), color=(255, 255, 255, 255), stroke_width=5)
self.add(self.south_stop_line)
self.west_stop_line = Line(start=(300, 300), end=(300, 500), color=(255, 255, 255, 255), stroke_width=5)
self.add(self.west_stop_line)
def draw_button(self):
self.add(self.north_normal_button)
self.add(self.east_normal_button)
self.add(self.south_normal_button)
self.add(self.west_normal_button)
self.add(self.north_emergency_button)
self.add(self.east_emergency_button)
self.add(self.south_emergency_button)
self.add(self.west_emergency_button)
def draw_light(self):
self.add(self.from_north_light)
self.add(self.from_south_light)
self.add(self.from_east_light)
self.add(self.from_west_light)
self.from_west_light.switch_signal()
self.from_east_light.switch_signal()
def add_car(self, type, from_direction):
car = None
if from_direction is "north":
car = Car(type, self.north_lane)
self.north_lane.add_car(car)
car.do(CustomizeMoveBy((0, -900), duration=4))
elif from_direction is "south":
car = Car(type, self.south_lane)
self.south_lane.add_car(car)
car.do(CustomizeMoveBy((0, 900), duration=4))
elif from_direction is "east":
car = Car(type, self.east_lane)
self.east_lane.add_car(car)
car.do(CustomizeMoveBy((-900, 0), duration=4))
elif from_direction is "west":
car = Car(type, self.west_lane)
self.west_lane.add_car(car)
car.do(CustomizeMoveBy((900, 0), duration=4))
self.add(car)
print car
self.car_queue.append(car)
def swtich_lights(self):
self.last_change_time = time.time()
self.from_north_light.switch_signal()
self.from_west_light.switch_signal()
self.from_east_light.switch_signal()
self.from_south_light.switch_signal()
def allow_vertical(self):
self.running_lane = "vertical"
self.last_change_time = time.time()
self.from_north_light.set_green()
self.from_south_light.set_green()
self.from_east_light.set_red()
self.from_west_light.set_red()
def allow_horizontal(self):
self.running_lane = "horizontal"
self.last_change_time = time.time()
self.from_west_light.set_green()
self.from_east_light.set_green()
self.from_north_light.set_red()
self.from_south_light.set_red()
def clear_central(self):
self.from_west_light.set_red()
self.from_east_light.set_red()
self.from_north_light.set_red()
self.from_south_light.set_red()
def has_emergency_car(self):
if not self.north_lane.has_emergency() and not self.south_lane.has_emergency() \
and not self.west_lane.has_emergency() and not self.east_lane.has_emergency():
return False
else:
return True
def has_waiting_car(self):
if self.north_lane.has_waiting_car() or self.south_lane.has_waiting_car() \
or self.west_lane.has_waiting_car() or self.east_lane.has_waiting_car():
return True
else:
return False
def has_emergency_waiting(self):
if not self.north_lane.has_emergency_waiting() and not self.south_lane.has_emergency_waiting() \
and not self.west_lane.has_emergency_waiting() and not self.east_lane.has_emergency_waiting():
return False
else:
return True
def is_empty(self):
if self.north_lane.normal_car_num + self.north_lane.emergency_car_num is 0 \
and self.south_lane.normal_car_num + self.south_lane.emergency_car_num is 0 \
and self.east_lane.normal_car_num + self.east_lane.emergency_car_num is 0 \
and self.west_lane.normal_car_num + self.west_lane.emergency_car_num is 0:
return True
else:
return False
def schedule(self, dt):
# print time.time() -self.last_change_time
# print "aging",self.aging
if time.time() - self.last_change_time > 4.0 and (self.aging or self.is_empty()):
# if self.aging or self.is_empty():
if not self.central_occupied:
if self.running_lane is "horizontal":
self.allow_vertical()
else:
self.allow_horizontal()
else:
self.clear_central()
else:
if not self.has_waiting_car():
self.aging = False
if not self.has_emergency_car():
if self.north_lane.normal_car_num > self.west_lane.normal_car_num and self.north_lane.normal_car_num > self.east_lane.normal_car_num \
or self.south_lane.normal_car_num > self.west_lane.normal_car_num and self.south_lane.normal_car_num > self.east_lane.normal_car_num:
if not self.central_occupied:
if self.running_lane is "horizontal":
self.allow_vertical()
for car in self.car_queue:
car.resume()
else:
if not self.central_occupied:
if self.running_lane is "vertical":
self.allow_horizontal()
for car in self.car_queue:
car.resume()
else:
if self.north_lane.emergency_car_num > self.west_lane.emergency_car_num and self.north_lane.emergency_car_num > self.east_lane.emergency_car_num \
or self.south_lane.emergency_car_num > self.west_lane.emergency_car_num and self.south_lane.emergency_car_num > self.east_lane.emergency_car_num:
if not self.central_occupied:
if self.running_lane is "horizontal":
self.allow_vertical()
for car in self.car_queue:
car.resume()
else:
if not self.central_occupied:
if self.running_lane is "vertical":
self.allow_horizontal()
for car in self.car_queue:
car.resume()
else:
self.clear_central()
else:
print "has waiting"
self.aging = True
if not self.has_emergency_waiting():
if self.north_lane.waiting_normal_car > self.west_lane.waiting_normal_car and self.north_lane.waiting_normal_car > self.east_lane.waiting_normal_car \
or self.south_lane.waiting_normal_car > self.west_lane.waiting_normal_car and self.south_lane.waiting_normal_car > self.east_lane.waiting_normal_car:
if not self.central_occupied:
if self.running_lane is "horizontal":
self.allow_vertical()
for car in self.car_queue:
car.resume()
else:
if not self.central_occupied:
if self.running_lane is "vertical":
self.allow_horizontal()
for car in self.car_queue:
car.resume()
else:
if self.north_lane.waiting_emergency_car > self.west_lane.waiting_emergency_car and self.north_lane.waiting_emergency_car > self.east_lane.waiting_emergency_car \
or self.south_lane.waiting_emergency_car > self.west_lane.waiting_emergency_car and self.south_lane.waiting_emergency_car > self.east_lane.waiting_emergency_car:
if not self.central_occupied:
if self.running_lane is "horizontal":
self.allow_vertical()
for car in self.car_queue:
car.resume()
else:
if not self.central_occupied:
if self.running_lane is "vertical":
self.allow_horizontal()
for car in self.car_queue:
car.resume()
else:
self.clear_central()
