def test_wheel_timer():
task_data = Path(utils.project_root() / 'tasks' / 'part-0-mock' / 'wheels.desc').read_text()
task = GridTask(Task.parse(task_data))
actionlist = ('QQDD' +
'F' +
'ZZZZZZZZZZZZZZZZZZZZ' +
'F' +
'ZZZZZZZZZZZZZZZZZZZZ' +
'ZZZZZZZZZ' +
'ZZZZZZZZZZZZZZZZZZZZ' +
'ZZZZZZZZZZZZZZZZZZZZ' +
'ZZZZZZZZZZ' +
'D')
game = Game(task)
for a in actionlist:
game.apply_action(Action.simple(a))
solution = compose_actions(game.get_actions())
expected_score = game.finished()
assert expected_score is None
game = Game(task)
for a in actionlist:
game.apply_action(Action.simple(a))
game.apply_action(Action.WSAD('D'))
solution = compose_actions(game.get_actions())
expected_score = game.finished()
er = validate.run(task_data, solution)
assert er.time is not None
assert er.time == expected_score
def test_visibility():
# Corner of 11th task
# 012345678
# 0 #...##...
# 1 #...##...
# 2 #...##...
# 3 ###.##...
# 4 ##.......
# 5 ##.......
# 6 ##.......
t = GridTask.from_problem(12)
grid = t.mutable_grid()
assert visible(grid, Pt(6, 2), Pt(6, 6))
assert not visible(grid, Pt(2, 2), Pt(2, 6))
# corners
assert visible(grid, Pt(1, 2), Pt(4, 3))
assert visible(grid, Pt(4, 3), Pt(1, 2))
assert visible(grid, Pt(5, 2), Pt(2, 3))
assert visible(grid, Pt(2, 3), Pt(5, 2))
assert visible(grid, Pt(1, 1), Pt(5, 5))
vis = render_visibility_grid(grid, Pt(13, 12))
def run_for_errors(actions: List[Action]):
task_data = Path(utils.project_root() / 'tasks' / 'part-0-mock' / 'prob-2003.desc').read_text()
task = GridTask(Task.parse(task_data))
game = Game(task)
try:
for a in actions:
game.apply_action(a)
except InvalidActionException:
return
else:
assert False
def test_grid_bb():
# bounding box optimization should be disabled for now
g = GridTask(
Task(
border=[Pt(14, 14), Pt(16, 14),
Pt(16, 17), Pt(14, 17)],
start=Pt(15, 15),
obstacles=[],
boosters=[],
))
assert g.width == 16
assert g.height == 17
def run_one_bot_game(actions: List[Action]):
task_data = Path(utils.project_root() / 'tasks' / 'part-0-mock' / 'prob-2003.desc').read_text()
task = GridTask(Task.parse(task_data))
game = Game(task)
for a in actions:
game.apply_action(a)
solution = compose_actions(game.get_actions())
expected_score = game.finished()
er = validate.run(task_data, solution)
assert er.time is not None
assert er.time == expected_score
def run_cloned_game(actions: List[List[Action]]):
task_data = Path(utils.project_root() / 'tasks' / 'part-0-mock' / 'prob-2003.desc').read_text()
task = GridTask(Task.parse(task_data))
game = Game(task)
indices = [0] * len(actions)
current = 0
while not game.finished():
if current == 0:
botcount = len(game.bots)
i = indices[current]
game.apply_action(actions[current][i], current)
indices[current] += 1
current = (current + 1) % botcount
solution = compose_actions(game.get_actions())
expected_score = game.finished()
er = validate.run(task_data, solution)
assert er.time is not None
assert er.time == expected_score
def __init__(self, task: GridTask):
self.task = task
self.grid = task.mutable_grid() # because drill
self.height = task.height
self.width = task.width
self.bots = [Bot(task.start)]
self.pending_boosters = []
self.inventory = Counter()
self.boosters = [b for b in task.boosters if b.code != 'X']
self.clone_spawn = [b.pos for b in task.boosters if b.code == 'X']
self.teleport_spots = []
self.turn = 0
self._wrapped = ByteGrid(self.grid.height, self.grid.width)
for y in range(self.height):
for x in range(self.width):
if self.grid[Pt(x, y)] != '.':
self._wrapped[Pt(x, y)] = 1
self._remaining_unwrapped = sum(1 for _, c in self.enumerate_grid()
if c == '.')
self.update_wrapped()
def interactive(task_number):
task_data = utils.get_problem_raw(task_number)
use_db = task_number <= 999
if use_db:
conn = db.get_conn()
cur = conn.cursor()
cur.execute(
'''
SELECT id, data FROM tasks WHERE name = %s
''', [f'prob-{task_number:03d}'])
[task_id, task_data_db] = cur.fetchone()
task_data_db = zlib.decompress(task_data_db).decode()
assert task_data_db == task_data
task = GridTask(Task.parse(task_data))
game = Game(task)
score = None
with contextlib.closing(Display(game)) as display:
code, c = '', ''
display.draw_initial(game)
while not score:
display.draw(game, f'lastchar = {code} {c!r}')
code = display.stdscr.getch()
action = None
c = chr(code).upper()
if c in '\x1B':
break
if c in Action.SIMPLE:
action = Action.simple(c)
# to perform complex action type it without spaces: B(1,-1)
elif c in Action.PARAM:
while c[-1] != ')':
code = display.stdscr.getch()
c = c + chr(code).upper()
action = Action.parameterized(c)
if display.current == 0:
botcount = len(game.bots)
if action:
try:
game.apply_action(action, display.current)
except InvalidActionException as exc:
display.draw_error(str(exc))
else:
display.current = (display.current + 1) % botcount
score = game.finished()
if score is not None:
print(f'Score: {score}')
result = validate_replay(task_data, score, game.get_actions())
print(result)
if use_db:
submit_replay(conn, task_id, result)
else:
mock_solutions = utils.project_root(
) / 'outputs' / 'mock_solutions'
mock_solutions.mkdir(parents=True, exist_ok=True)
with mock_solutions / f'prob-{task_number}.sol' as fin:
fin.write_text(result.solution)