def testDown(self):
rob.goto(0, 0)
for i in range(8):
rob.move_down()
self.assertEqual(rob.get_pos(), (i + 1, 0))
rob.goto(0, 0)
rob.move_down(9)
self.assertEqual(rob.get_pos(), (9, 0))
def testUp(self):
rob.goto(9, 0)
for i in range(8):
rob.move_up()
self.assertEqual(rob.get_pos(), (8 - i, 0))
rob.goto(9, 0)
rob.move_up(9)
self.assertEqual(rob.get_pos(), (0, 0))
def testRight(self):
rob.goto(0, 0)
for i in range(8):
rob.move_right()
self.assertEqual(rob.get_pos(), (0, i + 1))
rob.goto(0, 0)
rob.move_right(9)
self.assertEqual(rob.get_pos(), (0, 9))
def testLeft(self):
rob.goto(0, 9)
for i in range(8):
rob.move_left()
self.assertEqual(rob.get_pos(), (0, 8 - i))
rob.goto(0, 9)
rob.move_left(9)
self.assertEqual(rob.get_pos(), (0, 0))
def load_level(self, n):
rob.set_field_size(11, 11)
a = random.randint(1, 7)
b = random.randint(1, 3)
c = 1 if random.randint(0, 1) else -1
rob.goto(10, 5)
for i in range(a):
rob.put_wall(left=True, right=True)
rob.move_up()
if c == 1:
rob.put_wall(left=True, top=True)
else:
rob.put_wall(right=True, top=True)
for i in range(b):
if c == 1:
rob.move_right()
else:
rob.move_left()
rob.put_wall(top=True, bottom=True)
if c == -1:
rob.put_wall(left=True)
else:
rob.put_wall(right=True)
rob.set_parking_cell(*rob.get_pos())
rob.goto(10, 5)
def load_level(self, n):
rob.set_field_size(13, 20)
l = random.randint(10, 15)
corridors = [random.randint(0, 1) for i in range(l)]
rob.goto(10, 1)
for i in range(l):
rob.move_right()
rob.put_wall(bottom=True)
if not corridors[i]:
rob.put_wall(top=True)
continue
k = random.randint(1, 8)
for j in range(k):
rob.move_up()
pos = rob.get_pos()
rob.set_cell_type(pos[0], pos[1], rob.CELL_TO_BE_FILLED)
rob.put_wall(left=True, right=True)
rob.put_wall(top=True)
for j in range(k):
rob.move_down()
self.cells_to_fill = find_cells_to_be_filled()
rob.put_wall(right=True)
rob.set_parking_cell(10, 1)
rob.goto(10, 1)
def load_level(self, n):
m = random.randint(20, 40)
rob.set_field_size(3, m)
cells = list(range(1, m))
random.shuffle(cells)
cells = sorted(cells[:random.randint(7, m - 5)])
for i in cells:
rob.set_cell_type(1, i, rob.CELL_FILLED)
rob.goto(1, 0)
c = 0
while not rob.wall_is_on_the_right():
if rob.cell_is_filled():
c += 1
if c == 3:
break
else:
c = 0
rob.move_right()
rob.set_parking_cell(*rob.get_pos())
rob.goto(1, 0)
def load_level(self, n):
m = random.randint(20, 40)
rob.set_field_size(3, m)
rob.goto(1, 1)
d = 0
_d = 0
while not rob.wall_is_on_the_right():
if _d == 0:
pos = rob.get_pos()
rob.set_cell_type(pos[0], pos[1], rob.CELL_TO_BE_FILLED)
d += 1
_d = d
rob.move_right()
_d -= 1
self.cells_to_fill = find_cells_to_be_filled()
rob.set_parking_cell(1, m - 1)
rob.goto(1, 0)
def wrapper():
task_id = f.__name__
clazz = get_task_class(task_id)
passed = True
for i in range(clazz.CHECKS):
core.on_position_changed = None
_task = clazz()
with utils.allow_internal(True):
_task.load_level(i)
core.on_position_changed = viz.update_robot_position(delay)
core.on_cell_type_changed = viz.update_cell_color
with utils.allow_internal(True):
viz.render_maze(task_id)
core.on_position_changed(*core.get_pos())
crashed = False
error = False
try:
f()
except Exception as e:
logger.exception('Caught exception')
passed = False
error = True
if isinstance(e, core.RobotCrashed):
crashed = True
with utils.allow_internal(True):
passed = passed and _task.check_solution()
if passed:
logger.debug(
'Test #{} passed for task {}'.format(
i + 1, task_id))
viz.on_task_completed(True)
else:
logger.error(
'Test #{} failed for task {}'.format(
i + 1, task_id))
if crashed:
viz.on_robot_crashed()
elif error:
viz.on_task_errored()
else:
viz.on_task_completed(False)
break
return passed
def load_level(self, n):
rob.set_field_size(10, 10)
i = random.randint(2, 8)
l = random.randint(1, 8)
rob.goto(i, 1)
for k in range(l):
rob.put_wall(bottom=True)
rob.move_right()
rob.set_parking_cell(*rob.get_pos())
rob.goto(i, 1)
def load_level(self, n):
rob.set_field_size(10, 20)
l = random.randint(5, 12)
i = random.randint(2, 6)
j = random.randint(0, 5)
rob.goto(i, j)
for m in range(l):
k = random.randint(0, 1)
rob.put_wall(bottom=(k == 0), top=(k == 1))
rob.move_right()
rob.set_parking_cell(*rob.get_pos())
rob.goto(i, j)
def load_level(self, n):
m = random.randint(20, 40)
rob.set_field_size(3, m)
cells = list(range(1, m))
random.shuffle(cells)
cells = sorted(cells[:random.randint(7, m - 5)])
for k, i in enumerate(cells):
rob.goto(1, i)
rob.fill_cell()
if k == 4:
rob.set_parking_cell(*rob.get_pos())
rob.goto(1, 0)
def load_level(self, n):
l = random.randint(20, 30)
rob.set_field_size(13, l + 1)
corridors = [random.randint(0, 1) for i in range(l)]
self.filled_cells_number = 0
rob.goto(10, 0)
rob.put_wall(top=True, bottom=True)
rob.set_cell_type(10, 0, rob.CELL_TO_BE_FILLED)
for j in range(l - 1):
rob.move_right()
rob.put_wall(bottom=True)
if not corridors[j + 1]:
rob.put_wall(top=True)
rob.set_cell_type(10, j + 1, rob.CELL_TO_BE_FILLED)
continue
k = random.randint(1, 8)
for q in range(k):
rob.move_up()
pos = rob.get_pos()
if random.randint(0, 1) == 0:
rob.fill_cell()
self.filled_cells_number += 1
else:
rob.set_cell_type(pos[0], pos[1], rob.CELL_TO_BE_FILLED)
rob.put_wall(left=True, right=True)
rob.put_wall(top=True)
for q in range(k):
rob.move_down()
self.cells_to_fill = find_cells_to_be_filled() + find_filled_cells()
rob.set_parking_cell(10, l)
rob.goto(10, 0)
def check_solution(self):
return rob.get_pos() == (self.m - 1, self.n - 1)
def check_solution(self):
return rob.is_parking_cell(*rob.get_pos())
