def __init__(self, text=None, part2=False):
# 1. Set the initial values
self.part2 = part2
self.text = text
self.lift = elevator.Elevator(part2=part2)
self.floors = []
self.items = []
# 2. Process text (if any)
if text is not None and len(text) > 0:
# 3. Loop for all the text
for line in self.text:
# 4. Process elevator of floor
if line.startswith("The elevator"):
self.lift = elevator.Elevator(text=line, part2=self.part2)
else:
flr = floor.Floor(text=line, part2=self.part2)
self.floors.append(flr)
self.items.extend(flr.items)
# 5. put the items in alphabetic order
self.items.sort()
def test_multiple_elevators_basic(self):
''' Test 2 elevators and make sure it chooses the right one '''
LEVELS = "G 1 2 3 4 5 6 7 8 9".split()
elevator1 = elevator.Elevator(LEVELS)
elevator2 = elevator.Elevator(LEVELS)
controller = MultipleElevatorController([elevator1, elevator2])
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
self.assertEqual(elevator1.current_level, 0)
self.assertEqual(elevator2.direction, ElevatorDirection.UP)
self.assertEqual(elevator2.current_level, 0)
# Let's move elevator1 to level 8 so they are far away
elevator1.select_level(8)
while next(elevator1.generate_commands(), None):
elevator1.step_forward()
self.assertEqual(elevator1.current_level, 8)
# Now elevator1 has reached level 8
# So let's summon an elevator to go to level 2
# it should pick elevator2
self.assertEqual(controller.call_elevator(2, ElevatorDirection.UP),
elevator2)
def main():
# lists of floors must be ordered from lowest to highest floor
# names must be unique
floors = ('SB', 'B', 'L', '2', '3', '4', '5', '6', '7', '8', '9', '10')
# print(floors)
elev = elevator.Elevator(floors, floor="L")
btns = {
f + ",U": button.CallButton(f, elev, direc=Direction.UP)
for f in floors
}
btns.update({
f + ",D": button.CallButton(f, elev, direc=Direction.DOWN)
for f in floors
})
actions = ["3,D", "2,D", "6,U", "2,U"]
for b in actions:
btns[b].press()
elev.start()
def test_elevator_same_direction_out_of_sequence(self):
''' Test multiple people select floors in
same direction out of sequence '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(elevator1.current_level, 0)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
elevator1.select_level(4)
elevator1.select_level(3)
elevator1.select_level(2)
elevator1.select_level(1)
# this is our current level, should have no affect
elevator1.select_level(0)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP, # go to level 1
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP, # go to level 2
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP, # go to level 3
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP, # go to level 4
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
def test_elevator_go_below_ground_floor(self):
'''
If ground floor is the lowest we cannot go lower
Make sure it raises appropriate ElevatorOutOfBoundsException
'''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
with self.assertRaises(ElevatorOutOfBoundsException):
elevator1.select_level(-1)
def test_text_init(self):
"Test the Elevator object creation from text"
# 1. Create Solver object from text
myobj = elevator.Elevator(text=EXAMPLE_TEXT)
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 32)
self.assertEqual(myobj.floor, 2)
self.assertEqual(myobj.floors, 6)
self.assertEqual(len(myobj.items), 0)
self.assertEqual(myobj.last, 0)
self.assertEqual(myobj.direction, ' ')
# 3. Check Methods
self.assertEqual(str(myobj), "The elevator is on floor 2 of 6.")
self.assertEqual(myobj.directions(), ['U', 'D'])
self.assertEqual(myobj.next_floor('U'), 3)
self.assertEqual(myobj.next_floor('D'), 1)
self.assertFalse(myobj.can_move())
self.assertFalse(myobj.can_move_up())
self.assertFalse(myobj.can_move_down())
self.assertTrue(myobj.is_safe())
myobj.load([HYG])
self.assertTrue(myobj.is_safe())
self.assertEqual(len(myobj.items), 1)
self.assertTrue(myobj.can_move())
self.assertTrue(myobj.can_move_up())
self.assertTrue(myobj.can_move_down())
myobj.move_down()
self.assertEqual(myobj.floor, 1)
self.assertEqual(myobj.floors, 6)
self.assertEqual(myobj.last, 2)
self.assertEqual(myobj.direction, 'v')
self.assertEqual(str(myobj), "The elevator is on floor 1 of 6.")
self.assertEqual(myobj.directions(), ['U'])
self.assertTrue(myobj.can_move())
self.assertTrue(myobj.can_move_up())
self.assertFalse(myobj.can_move_down())
myobj.load([LIM])
self.assertEqual(len(myobj.items), 2)
self.assertFalse(myobj.is_safe())
stuff = myobj.unload()
self.assertEqual(len(myobj.items), 0)
self.assertEqual(len(stuff), 2)
self.assertTrue(myobj.is_safe())
self.assertFalse(myobj.can_move())
myobj.load([LIM])
self.assertTrue(myobj.can_move_up())
myobj.move_up()
self.assertEqual(myobj.last, 1)
self.assertEqual(myobj.direction, '^')
self.assertEqual(str(myobj), EXAMPLE_TEXT)
myobj.floor = myobj.floors
self.assertFalse(myobj.can_move_up())
self.assertTrue(myobj.can_move_down())
def test_elevator_go_above_roof(self):
'''
Try to go above roof and make sure it
raises appropriate ElevatorOutOfBoundsException
'''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
elevator1.select_level(4)
with self.assertRaises(ElevatorOutOfBoundsException):
elevator1.select_level(5)
def __init__(self, n, m, x, y, z, l):
self.n = n
self.m = m
self.z = z
self.l = l
self.elevators = [None]
for e in range(1, self.m + 1):
newElevator = elevator.Elevator(e, n, x, y, z)
self.elevators.append(newElevator)
print("Elevators Initialized.")
def test_elevator_same_direction_individually(self):
''' Test multiple people select floors in same
direction individually '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(elevator1.current_level, 0)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
# first go straight to level 2 from ground
elevator1.select_level(2)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# now let's select level 1
elevator1.select_level(1)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# now select level 3
elevator1.select_level(3)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
def test_multiple_elevators_advanced(self):
''' Test 3 elevators and make sure it chooses the right one '''
LEVELS = "G 1 2 3 4 5 6 7 8 9 10 11".split()
elevator1 = elevator.Elevator(LEVELS)
elevator2 = elevator.Elevator(LEVELS)
elevator3 = elevator.Elevator(LEVELS)
self.assertEqual(elevator1.current_level, 0)
self.assertEqual(elevator2.current_level, 0)
self.assertEqual(elevator3.current_level, 0)
controller = MultipleElevatorController(
[elevator1, elevator2, elevator3])
# Let's move elevator1 to level 10 so they are far away
elevator1.select_level(10)
while next(elevator1.generate_commands(), None):
elevator1.step_forward()
self.assertEqual(elevator1.current_level, 10)
# Let's move elevator2 to level 6 so they are far away
elevator2.select_level(6)
while next(elevator2.generate_commands(), None):
elevator2.step_forward()
self.assertEqual(elevator2.current_level, 6)
# Now let's summon a lift to go DOWN at level 5
# it should be lift 2
self.assertEqual(controller.call_elevator(5, ElevatorDirection.DOWN),
elevator2)
# Now let's summon a lift to go UP at level 2
# it should be lift 3
self.assertEqual(controller.call_elevator(2, ElevatorDirection.UP),
elevator3)
# Now let's summon a lift to go DOWN to level 9
# it should be lift 1
self.assertEqual(controller.call_elevator(9, ElevatorDirection.DOWN),
elevator1)
def test_call_elevator_at_floor_3_from_ground(self):
elevator1 = elevator.Elevator("G 1 2 3 4".split())
elevator1.call_elevator(3, ElevatorDirection.UP)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
def test_empty_init(self):
"Test the default Elevator creation"
# 1. Create default Elevator object
myobj = elevator.Elevator()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
self.assertEqual(myobj.floor, 1)
self.assertEqual(myobj.floors, 4)
self.assertEqual(len(myobj.items), 0)
self.assertEqual(myobj.last, 0)
self.assertEqual(myobj.direction, ' ')
# 3. Check methods
self.assertEqual(str(myobj), "The elevator is on floor 1 of 4.")
self.assertEqual(myobj.directions(), ['U'])
def test_empty_floor(self):
"Test the Floor object creation from text with no items"
# 1. Create Solver object from text
myobj = floor.Floor(text=EMPTY_TEXT)
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 43)
self.assertEqual(myobj.number, 4)
self.assertEqual(myobj.ordinal, "fourth")
self.assertEqual(len(myobj.items), 0)
# 3. Check Methods
self.assertEqual(str(myobj), EMPTY_TEXT)
self.assertEqual(myobj.has(HYG), False)
self.assertEqual(myobj.has(HYM), False)
self.assertEqual(myobj.elements(), set())
self.assertEqual(len(myobj.generators()), 0)
self.assertEqual(len(myobj.microchips()), 0)
self.assertEqual(myobj.safely_removable(), [])
lift = elevator.Elevator()
lift.floor = 4
self.assertEqual(myobj.trace(lift, TRACE), "F4 E ... ... ... ...")
self.assertEqual(myobj.is_safe(), True)
self.assertEqual(myobj.is_empty(), True)
myobj.add(HYG)
self.assertEqual(myobj.trace(lift, TRACE), "F4 E HyG ... ... ...")
self.assertEqual(myobj.is_safe(), True)
self.assertEqual(myobj.is_empty(), False)
items = myobj.safely_removable()
self.assertEqual(len(items), 1)
self.assertEqual(len(items[0]), 1)
self.assertEqual(items[0][0], HYG)
myobj.add(LIM)
self.assertEqual(myobj.is_safe(), False)
self.assertEqual(myobj.is_empty(), False)
lift.load([LIG])
lift.move_down()
self.assertEqual(myobj.trace(lift, TRACE), "F4 v HyG ... ... LiM")
self.assertEqual(myobj.is_safe(), False)
self.assertEqual(len(myobj.safely_removable()), 2)
def robotInit(self):
'''Robot-wide initialization code should go here'''
self.drivetrain = drivetrain.Drivetrain()
self.sensors = sensor_handler.sensorHandler()
self.joystick = joystick_handler.JoystickHandler()
self.elevator = elevator.Elevator()
self.intakeHandler = intake.Intake(self.sensors, self.joystick)
self.auto = Autonomous_mode_handler.AutonomousModeHandler(
self.drivetrain, self.sensors, self.elevator, self.intakeHandler)
self.autoPath = auto_path.AutoPath(self.sensors, self.drivetrain)
self.chooser = wpilib.SendableChooser()
self.chooser.addObject('center', 'robot_constant.CENTER_POS')
self.chooser.addObject('left', 'robot_constant.LEFT_POS')
self.chooser.addObject('right', 'robot_constant.RIGHT_POS')
self.chooser.addObject('default', 'robto_constant.DEFAULT')
wpilib.SmartDashboard.putData('Auto Mode', self.chooser)
logging.basicConfig(filename='robotLogs.log', level=logging.DEBUG)
logging.info("Init robot")
def test_call_outside_and_inside_same_direction(self):
''' multiple people both calling outside and
selecting stop inside to go same direction '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
elevator1.call_elevator(3, ElevatorDirection.UP)
elevator1.call_elevator(1, ElevatorDirection.UP)
elevator1.select_level(2)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
def test_elevator_same_floor(self):
''' test selecting the same floor '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(elevator1.current_level, 0)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
# first go straight to level 2 from ground
elevator1.select_level(2)
elevator1.select_level(2)
elevator1.select_level(2)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
def controller():
""" Main Function()
This function is the beginning of the simulation. The elevator instances are created and
the tic is set to zero. In a while-loop, our program fulfills all its jobs and calls all
functions that are further needed. The loop starts with updating the elevator, then takes
an input (input-reader()). The input is then assigned to a special- and a common-list.
Those lists are then run through their own job assigner and remaining jobs are saved for
later assignment.
If at the end of the loop an elevator is in idle (10), another 10 is added to the list and
the state of idle stays.
At the end of every loop the tic is increased by one.
"""
tic = 0
remaining_common_jobs = []
remaining_spec_jobs = []
elevator_a = elevator.Elevator("A", 0, "none", [10])
elevator_b = elevator.Elevator("B", 0, "none", [10])
remaining_jobs = []
while True:
print("Tic is:", tic)
testcase_writer(elevator_a, elevator_b, tic)
# sets the new attributes for our elevators
elevator_setter(elevator_a, tic)
elevator_setter(elevator_b, tic)
tui_interface(elevator_a, elevator_b, tic)
inp = input_reader()
common_jobs, special_jobs = job_list_builder(inp)
remaining_spec_jobs = delete_doubles(remaining_spec_jobs)
special_jobs.extend(remaining_spec_jobs)
remaining_common_jobs = delete_doubles(remaining_common_jobs)
common_jobs.extend(remaining_common_jobs)
common_jobs = delete_doubles(common_jobs)
elevator_a.elevator_printer(tic)
elevator_b.elevator_printer(tic)
# here we assign the specific jobs and saves the remaining_jobs in a list
remaining_spec_jobs = job_feeder.spec_job_assigner(
elevator_a, tic, special_jobs) + job_feeder.spec_job_assigner(
elevator_b, tic, special_jobs)
print("Common Jobs are:", common_jobs)
# common jobs are assigned here
for inp in common_jobs:
if len(inp) > 2:
inp = [inp[0:2], inp[2]]
distance_a = job_feeder.common_job_comparer(elevator_a, inp, tic)
distance_b = job_feeder.common_job_comparer(elevator_b, inp, tic)
if distance_b == "no match" and distance_a == "no match":
if inp[0] == "-1":
remaining_common_jobs.append("-1h")
else:
remaining_common_jobs.append(inp)
continue
if distance_a == "no match":
distance_a = 1000
if distance_b == "no match":
distance_b = 1000
if len(elevator_b.spec_list[tic:]) > 1 and len(
elevator_a.spec_list[tic:]) > 1:
if distance_a > distance_b:
job_feeder.assign_common_stop(inp[0], elevator_b,
distance_b, tic)
print("Job assigned to B. Distance to job is:", distance_b)
try:
if inp[0] == "-1":
remaining_common_jobs.remove("-1h")
else:
remaining_common_jobs.remove(inp)
except ValueError:
continue
else:
job_feeder.assign_common_stop(inp[0], elevator_a,
distance_a, tic)
print("Job assigned to A. Distance to job is:", distance_a)
try:
if inp[0] == "-1":
remaining_common_jobs.remove("-1h")
else:
remaining_common_jobs.remove(inp)
except ValueError:
continue
elif elevator_a.spec_list[tic] == 10 and len(
elevator_a.spec_list[tic:]) == 1:
print("Job was assigned to A.")
job_feeder.assign_common_stop(inp[0], elevator_a, distance_a,
tic)
try:
if inp[0] == "-1":
remaining_common_jobs.remove("-1h")
else:
remaining_common_jobs.remove(inp)
except ValueError:
continue
elif elevator_b.spec_list[tic] == 10 and len(
elevator_b.spec_list[tic:]) == 1:
print("Job assigned to B.")
job_feeder.assign_common_stop(inp[0], elevator_b, distance_b,
tic)
try:
if inp[0] == "-1":
remaining_common_jobs.remove("-1h")
else:
remaining_common_jobs.remove(inp)
except ValueError:
continue
if len(elevator_b.spec_list[tic:]) == 1:
elevator_b.spec_list.extend([10])
if len(elevator_a.spec_list[tic:]) == 1:
elevator_a.spec_list.extend([10])
tic += 1
def test_elevator_opposite_direction(self):
''' Test multiple people select floors in opposite direction '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(elevator1.current_level, 0)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
# first go straight to level 2 from ground
elevator1.select_level(2)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
elevator1.step_forward()
elevator1.step_forward()
elevator1.step_forward()
elevator1.step_forward()
# Make sure we are on level 2
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(elevator1.current_level, 2)
self.assertEqual(list(elevator1.generate_commands()), [])
# Now let's select level 4,
# THEN level 1, and make sure it works correctly
elevator1.select_level(4)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# select level 1
elevator1.select_level(1)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.DOWN,
ElevatorCommand.DOWN,
ElevatorCommand.DOWN,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# Now STEP FORWARD to LEVEL 4 and see if elevator DIRECTION is changed
elevator1.step_forward()
elevator1.step_forward()
elevator1.step_forward() # open door on level 4
elevator1.step_forward() # close door on level 4
elevator1.step_forward()
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.DOWN,
ElevatorCommand.DOWN,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
self.assertEqual(elevator1.direction, ElevatorDirection.DOWN)
def load(self):
levels = self.get_levels()
if self.level_id > len(levels) - 1:
self.app.set_state(main.WIN)
self.app.score_manager.save()
else:
self.app.gui_manager.set_state(gui_manager.FADE_IN)
self.app.game_manager.clear_level()
self.level_name = levels[self.level_id]
self.app.gui_manager.update_times(
self.app.score_manager.run_scores.get(
util.get_filename(self.mode, self.level_name), 0),
self.app.score_manager.get_record(self.mode, self.level_name))
# map_data = levels.levels[self.level_id]()
if self.mode == 0:
directory = 'levels'
elif self.mode == 1:
directory = 'survival'
with open('{}/{}.dat'.format(directory, self.level_name),
'rb') as f:
map_data = pickle.load(f)
scene = self.app.renderer.scene
model_name, texture = map_data['terrain']
self.app.game_manager.terrain = terrain.Terrain(
self.app, model_name, texture)
scene.add(self.app.game_manager.terrain.canvas)
self.app.game_manager.player.spawn(map_data['spawn_pos'])
if self.mode == 0:
self.app.game_manager.goal.spawn(map_data['goal_pos'])
elif self.mode == 1:
self.app.game_manager.goal.despawn()
for data in map_data['buildings']:
b = building.Building(self.app,
building.Building.data[data[0]],
data[1:4], data[4])
# b = building.Building(self.app, building.Building.data[data[0]], data[1:4], 0)
self.app.game_manager.game_objects.add(b)
scene.add(b.canvas)
for data in map_data['platforms']:
if data[0] == 0:
platform.Hedge(self.app, data[1:4])
elif data[0] == 1:
platform.InvisiblePlatform(self.app, data[1:4])
elif data[0] == 2:
platform.LavaPlatform(self.app, data[1:4])
elif data[0] == 3:
platform.Trampoline(self.app, data[1:4])
for data in map_data['elevators']:
e = elevator.Elevator(self.app, data[1:4], data[4])
self.app.game_manager.game_objects.add(e) # spawn later
scene.add(e.canvas)
for data in map_data['powerups']:
if data[0] == 0:
e = powerup.Fuel(self.app, data[1:4])
self.app.game_manager.game_objects.add(e) # spawn later
scene.add(e.canvas)
elif data[0] == 1:
e = powerup.Health(self.app, data[1:4])
self.app.game_manager.game_objects.add(e) # spawn later
scene.add(e.canvas)
elif data[0] == 2:
e = powerup.SlowTime(self.app, data[1:4])
self.app.game_manager.game_objects.add(e) # spawn later
scene.add(e.canvas)
for data in map_data['vehicles']:
if data[0] == 0:
v = car.Car(self.app)
elif data[0] == 1:
v = helicopter.Helicopter(self.app)
v.spawn(data[1:4])
for data in map_data['enemies']:
if data[0] == 0:
enemy.Turret(self.app, data[1:4])
elif data[0] == 1:
enemy.Bee(self.app, data[1:4])
elif data[0] == 2:
enemy.BowlSpawner(self.app, data[1:4])
elif data[0] == 3:
enemy.InvisibleEnemy(self.app, data[1:4])
self.app.game_manager.set_state(self.mode)
def setUpClass(cls):
cls.elevator = elevator.Elevator(1)
def test_elevator_go_up_down(self):
''' Test some basic UP and DOWN commands '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
# go to level 3
elevator1.select_level(3)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP, ElevatorCommand.UP, ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR, ElevatorCommand.CLOSE_DOOR
],
)
elevator1.step_forward()
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.MOVING_UP)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP, ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR, ElevatorCommand.CLOSE_DOOR
],
)
elevator1.step_forward()
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.MOVING_UP)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP, ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR
],
)
elevator1.step_forward()
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.MOVING_UP)
self.assertEqual(
list(elevator1.generate_commands()),
[ElevatorCommand.OPEN_DOOR, ElevatorCommand.CLOSE_DOOR],
)
elevator1.step_forward()
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.OPEN)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(
list(elevator1.generate_commands()),
[ElevatorCommand.CLOSE_DOOR],
)
# We finished getting to level 3, nothing left to do
elevator1.step_forward()
self.assertEqual(elevator1.door_status, ElevatorDoorStatus.CLOSED)
self.assertEqual(elevator1.status, ElevatorStatus.IDLE)
self.assertEqual(list(elevator1.generate_commands()), [])
self.assertEqual(elevator1.current_level, 3)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
# Now test GOING DOWN
elevator1.select_level(0)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.DOWN, ElevatorCommand.DOWN,
ElevatorCommand.DOWN, ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR
],
)
self.assertEqual(elevator1.direction, ElevatorDirection.DOWN)
def test_multiple_people_dif_floors_same_direction(self):
elevator1 = elevator.Elevator("G 1 2 3 4".split())
elevator1.call_elevator(3, ElevatorDirection.UP)
elevator1.call_elevator(1, ElevatorDirection.UP)
elevator1.call_elevator(2, ElevatorDirection.UP)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# Go up
elevator1.step_forward()
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# open door
elevator1.step_forward()
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
# close door
elevator1.step_forward()
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
self.assertEqual(elevator1.current_level, 1)
for i in range(6):
elevator1.step_forward()
# finish the sequence
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
self.assertEqual(elevator1.current_level, 3)
def test_multiple_people_diff_floors_opposite_direction(self):
''' multiple people both calling outside and
selecting stop inside to go same direction '''
elevator1 = elevator.Elevator("G 1 2 3 4".split())
self.assertEqual(elevator1.direction, ElevatorDirection.UP)
# Call the elevator
elevator1.call_elevator(3, ElevatorDirection.UP)
elevator1.call_elevator(1, ElevatorDirection.UP)
elevator1.call_elevator(1, ElevatorDirection.DOWN)
# select a level from inisde
elevator1.select_level(2)
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.DOWN,
ElevatorCommand.DOWN,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
for i in range(8):
# get to level 3
elevator1.step_forward()
self.assertEqual(elevator1.direction, ElevatorDirection.DOWN)
elevator1.call_elevator(0, ElevatorDirection.UP)
elevator1.call_elevator(4, ElevatorDirection.DOWN)
# Now we have to go down to level 1 from that
# guy above who's been waiting since the start
# then we go to Ground to service the new guy who clicked up
# and all the way to 4 to for the new guy who clicked down
self.assertEqual(
list(elevator1.generate_commands()),
[
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.DOWN,
ElevatorCommand.DOWN,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.DOWN,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.UP,
ElevatorCommand.OPEN_DOOR,
ElevatorCommand.CLOSE_DOOR,
],
)
for i in range(14):
elevator1.step_forward()
self.assertEqual(elevator1.direction, ElevatorDirection.DOWN)
self.assertEqual(elevator1.current_level, 4)
def __init__(self, el_del: int):
self.elevator = elevator.Elevator(el_del)
self.flag_for_output = True
print("Объект создан")
