def test_grid():
# Positive tests
# 1.The first test case for grid_to_string function
# 2.create one grid
grid_one = read_lines("board_simple.txt")
# 3.create one player
player = Player(0, 2)
# 4.test if grid_to_string function work fine
assert grid_to_string(grid_one,
player) == "**A**\n* *\n**Y**\n\nYou have 0 " \
"water buckets.", "Test one did not pass"
print("Test case 1 for Grid pass")
# 5.The second test case for grid_to_string function
# 6.create the second grid for testing
grid_two = read_lines("board_medium.txt")
# 7.creat one player
player = Player(0, 2)
# 8.test if grid_to_string function works fine
assert grid_to_string(grid_two, player) == "**A***\n* *\n* ** *\n* *\n* *\n" \
"****Y*\n\nYou have 0 water buckets.", "Test t" \
"wo did not pass "
print("Test case 2 for Grid pass")
# The third test case for grid_to_string function
grid_three = read_lines("board_normal.txt")
player = Player(0, 2)
assert grid_to_string(grid_three
, player) == "**A****\n* " \
"3 *\n* 3 *\n****Y**\n" \
"\nYou have 0 water " \
"buckets.", "Test three did not pass."
print("Test case 3 for Grid pass")
def test_grid():
assert grid_to_string(parse(read_lines("board_test.txt")), p) == """*X*
*Y*
You have 0 water buckets.""", "Test case 1 failed"
print("Simple Grid to String passed!")
assert grid_to_string(parse(read_lines("board_test.txt")), o) == """*X*
*Y*
You have 1 water bucket.""", "Test case 2 failed"
print("Increase Water Bucket to String passed!")
assert grid_to_string(parse(read_lines("board_test.txt")), c) == """*X*
*Y*
You have p water buckets.""", "Test case 3 failed"
print("Various amounts of water buckets case passed!")
assert grid_to_string(parse(read_lines("board_test.txt")), d) == """*X*
*Y*
You have water buckets.""", "Test case 4 failed"
print("No water buckets case passed!")
assert grid_to_string(parse(read_lines("board_test.txt")), e) == """*X*
*Y*
You have !@#$%^&*() water buckets.""", "Test case 5 failed"
print("Various amounts of water buckets case 2 passed!")
try:
grid_to_string((1), e)
print("Test Case Grid to String TypeError Failed!")
except TypeError:
print("Test Case Grid to String TypeError Passed!")
def test_parse():
try:
grid_bad_letter = read_lines("board_bad_letter.txt")
assert False
except ValueError:
print("Test 04: Bad Letter Check passed!")
except AssertionError:
print("Test 04: Bad Letter Check failed! (did not throw an exception)")
try:
grid_no_starting = read_lines("board_no_starting.txt")
assert False
except ValueError:
print("Test 05: Starting Point Check passed!")
except AssertionError:
print("Test 05: Starting Point Check failed! (did not throw an exception)")
try:
grid_no_ending = read_lines("board_no_ending.txt")
assert False
except ValueError:
print("Test 06: Ending Point Check passed!")
except AssertionError:
print("Test 06: Ending Point Check failed! (did not throw an exception)")
try:
grid_mismatch_port = read_lines("board_mismatch_port.txt")
assert False
except ValueError:
print("Test 07: Port Pad Match Check passed!")
except AssertionError:
print("Test 07: Port Pad Match Check failed! (did not throw an exception)")
def test_read_lines():
''' Empty configuration file '''
try:
read_lines('board_empty.txt')
except AssertionError:
print("read_lines: Testcase 1 failed (did not throw an exception)")
except ValueError:
pass
def test_read_lines():
#test board_medium.txt: positive test case
assert isinstance(read_lines("board_medium.txt")[0][2],
Start), "Coordinate 0,2 is not a Start Cell"
assert isinstance(read_lines("board_medium.txt")[5][4],
End), "Coordinate 5,4 is not a End Cell"
assert isinstance(read_lines("board_medium.txt")[1][1],
Air), "Coordinate 1,1 is not a Air Cell"
assert isinstance(read_lines("board_medium.txt")[0][5],
Wall), "Coordinate 0,5 is not a Wall Cell"
#test file with grid only made of Fire cells: edge case
all_fire = True
for row in read_lines("fire.txt"):
for cell in row:
if isinstance(cell, Fire) == False and isinstance(
cell, Start) == False and isinstance(cell, End) == False:
all_fire = False
assert all_fire == True, "Non-fire (or start/end) cell detected."
#test file with 4 teleports of the same number: negative test case
value_error_caught = False
try:
read_lines("board_four_teleports.txt")
except:
ValueError
value_error_caught = True
assert value_error_caught == True
#test file with just XY: edge case
assert isinstance(read_lines("board_XY.txt")[0][0],
Start), "Coordinate 0,0 is not a Start Cell"
assert isinstance(read_lines("board_XY.txt")[0][1],
End), "Coordinate 0,1 is not a End Cell"
def test_game():
game = Game("board_simple.txt")
grid = read_lines(game.filename)
coords_result = {
'X': [[0, 2]],
' ': [[1, 1], [1, 2], [1, 3]],
'Y': [[2, 2]],
'*': [[0, 0], [0, 1], [0, 3], [0, 4], [1, 0], [1, 4], [2, 0], [2, 1],
[2, 3], [2, 4]],
'W': [],
'F': [],
'1': [],
'2': [],
'3': [],
'4': [],
'5': [],
'6': [],
'7': [],
'8': [],
'9': [],
'A': []
}
try:
assert game.collect_coords(grid) == coords_result
print("Test 09: Coordinates Collection passed!")
except AssertionError:
print("Test 09: Coordinates Collection failed!")
def main():
if len(sys.argv) < 3:
print("Usage: python3 solver.py <filename> <mode>")
sys.exit(0)
file = sys.argv[1]
game = Game(file)
# *** get grid ***
grid = read_lines(file)
# *** get coords ***
game_coords = game.collect_coords(grid)
# set player to start point
game.player.row = game_coords['X'][0][0]
game.player.col = game_coords['X'][0][1]
if sys.argv[2] == "DFS":
result, count, trace = dfs(game, game_coords)
elif sys.argv[2] == "BFS":
result, count, trace = bfs(game, game_coords)
return result, count, trace
def __init__(self, filename, player):
#Initialize game attributes
self.grid = read_lines(filename)
self.player = player
self.display = grid_to_string(self.grid, self.player)
self.player_coordinate = grid_start(self.grid)
self.player_col = self.player_coordinate.get_col()
self.player_row = self.player_coordinate.get_row()
self.player_water_buckets = 0
#Initialize move trackers
self.num_moves = 0
self.moves_made = []
#Move effects
self.hit_wall = False
self.fire_extinguished = False
self.has_teleported = False
self.invalid_move = False
self.found_water = False
self.won = False
self.lost = False
self.consecutive_waits = 0 #Used to keep solver waiting too many times
#Initialize player attributes
self.player.game = self
self.player.coordinate = self.player_coordinate
self.player.col = self.player_col
self.player.row = self.player_row
def test_player():
player = Player()
## Testing Player.move() ##
## Positive test cases ##
assert player.move('a') == 'a', 'Positive test case 1 failed, move "a".'
assert player.move('w') == 'w', 'Positive test case 2 failed, move "w".'
assert player.move('s') == 's', 'Positive test case 3 failed, move "s".'
assert player.move('d') == 'd', 'Positive test case 4 failed, move "d".'
assert player.move('e') == 'e', 'Positive test case 5 failed, move "e".'
## Negative test cases ##
assert player.move(
5) == None, 'Negative test case 1 failed, non-string move.'
## Edge cases ##
## Testing Player.initial_player_position() ##
## Positive test cases ##
grid = game_parser.parse(game_parser.read_lines('board_simple.txt'))
assert player.initial_player_position(grid) == [
0, 2
], 'Positive test case 1 failed.'
grid = game_parser.parse(game_parser.read_lines('board_medium.txt'))
assert player.initial_player_position(grid) == [
0, 2
], 'Positive test case 2 failed.'
grid = game_parser.parse(game_parser.read_lines('board_hard.txt'))
assert player.initial_player_position(grid) == [
0, 1
], 'Positive test case 3 failed.'
grid = game_parser.parse(game_parser.read_lines('board.txt'))
assert player.initial_player_position(grid) == [
0, 1
], 'Positive test case 4 failed.'
grid = game_parser.parse(game_parser.read_lines('board_test.txt'))
assert player.initial_player_position(grid) == [
1, 0
], 'Positive test case 5 failed.'
## Negative test cases ##
assert player.initial_player_position(
'string') == None, 'Negative test case 1 failed.'
assert player.initial_player_position(
[1, 2, 3]) == None, 'Negative test case 2 failed.'
assert player.initial_player_position(
[]) == None, 'Negative test case 3 failed.'
def test_grid_simple():
grid = read_lines('board_simple2.txt')
game_object = Game('board_simple2.txt')
game_object.start()
output = '***\nA Y\n***\n\nYou have 0 water buckets.'
assert output == grid_to_string(grid,
game_object.player), "Invalid grid display"
print('Simple grid test passed')
def __init__(self, filename):
self.filename = filename
self.moves_made = []
self.move_ct = 0
self.player = None
self.map = read_lines(filename)
self.message = None
self.death = False
self.win = False
def __init__(self, filename):
self.cells=read_lines(filename)
self.moves=[]
self.move_count=0
self.player=Player(self)
self.temp_move=''
self.state='running'
self.traversed=[]
self.bounds=[len(self.cells)-1,len(self.cells[0])-1]
def test_grid():
grid = read_lines("board_simple.txt")
player = Player([0, 0])
string_result_one = "A*X**\n* *\n**Y**\n\nYou have 0 water buckets.\n"
try:
assert grid_to_string(grid, player) == string_result_one
print("Test 08: Grid To String passed!")
except AssertionError:
print("Test 08: Grid To String failed!")
def test_run():
game = Game("board_simple.txt")
grid = read_lines("board_simple.txt")
game_coords = game.collect_coords(grid)
try:
assert search_coords(game_coords, [1, 2]) == ' '
assert search_coords(game_coords, [2, 2]) == 'Y'
print("Test 10: Coordinates Search passed!\n")
except AssertionError:
print("Test 10: Coordinates Search failed!\n")
def test_grid():
player = Player()
## Positive test cases ##
grid = game_parser.parse(game_parser.read_lines('board_simple.txt'))
assert grid_to_string(grid, player) == "A*X**\n* *\n**Y**\n\nYou have 0 water buckets.", "Positive test case 1 failed."
grid = game_parser.parse(game_parser.read_lines('board_medium.txt'))
assert grid_to_string(grid, player) == "A*X***\n* *\n* ** *\n* *\n* *\n****Y*\n\nYou have 0 water buckets.", "Positive test case 2 failed."
grid = game_parser.parse(game_parser.read_lines('board_hard.txt'))
assert grid_to_string(grid, player) == "AX*************\n* 2 * *\n* *** ** **** *\n* * W* 1 *\n* ***** ***** *\n* 2 * ** *F*\n* ** *** *\n* 1********F *\n*************Y*\n\nYou have 0 water buckets.", "Positive test case 3 failed."
grid = game_parser.parse(game_parser.read_lines('board.txt'))
assert grid_to_string(grid, player) == "AXY*********\n* *\n* 1 *\n* *\n*** *\n*1* *\n************\n\nYou have 0 water buckets.", "Positive test case 4 failed."
grid = game_parser.parse(game_parser.read_lines('1move.txt'))
assert grid_to_string(grid, player) == "A*\nXY\n**\n\nYou have 0 water buckets.", "Positive test case 5 failed."
## Negative test cases ##
grid = game_parser.parse(game_parser.read_lines('board_simple.txt'))
assert grid_to_string(grid, 'Jack') == None, 'Negative test case 1 failed, player is not a Player object.'
assert grid_to_string(34, player) == None, 'Negative test case 2 failed, grid is not a list.'
bad_grid = [1, 2, 'a']
assert grid_to_string(bad_grid, player) == None, 'Negative test case 3 failed, element in grid is not a list.'
## Edge cases ##
empty_grid = []
assert grid_to_string(empty_grid, player) == None, 'Edge case 1 failed, empty grid.'
def __init__(self, filename):
self.player = Player()
self.filename = filename
self.moves_made = []
self.finished = False
self.lost = False
self.grid = read_lines(filename)
self.msg = ''
self.start()
# Attributes used by the solver
self.picked_bucket = False
self.on_tp_pad = False
def solve(maze):
nums = []
add = ''
nums.append(add)
maze = parse(read_lines(filename))
while not find_end(maze, add):
add = nums[0]
nums.remove(nums[0])
for j in ["a", "d", "w", "s"]:
put = add + '{}, '.format(j)
if valid(maze, put):
nums.append(put)
return True
def __init__(self, filename):
self.exit = False
self.filename = filename
self.Player1 = Player()
self.grid = read_lines(self.filename)
self.success = False
self.failure = False
self.teleport = False
self.total_moves = []
self.total_moves_count = 0
self.oob = False
self.incorrect_input = False
self.e_count = 0
def __init__(self, filename):
self.filename = filename
self.grid = read_lines(filename)
self.row = 0
self.col = 0
self.find_x()
self.player = Player(self.row, self.col)
self.print_water = 0
self.print_fire = 0
self.print_live_fire = 0
self.print_wall = 0
self.print_magic = 0
self.print_end_game = 0
self.bad_input = 0
def test_game():
player = Player()
player.row = 0
player.col = 1
game = Game('board_hard.txt')
grid = parse(read_lines('board_hard.txt'))
## Testing gameMove() ##
## Positive test cases ##
assert game.gameMove('a') == [1, 'a, '], 'Positive testcase 1 failed.'
assert game.gameMove('d') == [2, 'a, d, '], 'Positive testcase 2 failed.'
assert game.gameMove('s') == [3,
'a, d, s, '], 'Positive testcase 3 failed.'
assert game.gameMove('w') == [4, 'a, d, s, w, '
], 'Positive testcase 5 failed.'
## Negative test cases ##
assert game.gameMove(
1) == None, 'Negative testcase 1 failed, integer type move.'
assert game.gameMove(
[]) == None, 'Negative testcase 2 failed, list type move.'
## Edge cases ##
## move_action() ##
## Positive test cases ##
assert game.move_action(grid, player,
's') == '', 'Postive testcase 1 failed.'
assert game.move_action(grid, player,
'a') == '', 'Positve testcase 2 failed.'
## Negative test cases ##
assert game.move_action(grid, player,
1) == None, 'Negative testcase 1 failed'
## Edge cases ##
player.row = -1
player.col = 1
assert game.move_action(
grid, player, 'w'
) == '\nYou walked into a wall. Oof!\n', 'Edgecase 1 failed, should act as a wall when stepping off the grid.'
player.row = 1
player.col = -1
assert game.move_action(
grid, player, 'a'
) == '\nYou walked into a wall. Oof!\n', 'Edgecase 2 failed, should act as a wall when stepping off the grid.'
def main():
file = sys.argv[1]
game = Game(file)
grid = read_lines(file)
game_coords = game.collect_coords(grid)
game.player.row = game_coords['X'][0][0]
game.player.col = game_coords['X'][0][1]
if sys.argv[2] == "DFS":
result, count, trace = dfs(game, game_coords)
elif sys.argv[2] == "BFS":
result, count, trace = bfs(game, game_coords)
return result, count, trace
def test_grid_super_hard():
grid = read_lines('board_super_hard.txt')
game_object = Game('board_super_hard.txt')
output = """*A*************
* 2 * W*
* *** ** **** *
* * WW* 1 *
* ***** ***** *
* 2 * ** *F*
*W**W*** FFF*
* 1********FFF*
*************Y*
You have 0 water buckets."""
assert output == grid_to_string(grid,
game_object.player), "Invalid grid display"
print("Super hard grid test passed")
def test_parse():
assert type(parse(read_lines("parsetest1.txt"))[0]
[0]) == Start, "Parse Start Case Failed!"
print("Parse Start Case Passed!")
assert type(parse(
read_lines("parsetest1.txt"))[0][1]) == End, "Parse End Case Failed!"
print("Parse End Case Passed!")
assert type(parse(
read_lines("parsetest1.txt"))[0][2]) == Wall, "Parse Wall Case Failed!"
print("Parse Wall Case Passed!")
assert type(parse(read_lines("parsetest1.txt"))[0]
[3]) == Teleport, "Parse Teleport Case Failed!"
print("Parse Teleport Case Passed!")
assert type(parse(read_lines("parsetest1.txt"))[0]
[4]) == Teleport, "Parse Teleport Case Failed!"
print("Parse Teleport Case Passed!")
assert type(parse(
read_lines("parsetest1.txt"))[0][5]) == Fire, "Parse Fire Case Failed!"
print("Parse Fire Case Passed!")
assert type(parse(read_lines("parsetest1.txt"))[0]
[6]) == Water, "Parse Water Case Failed!"
print("Parse Water Case Passed!")
try:
parse(read_lines("parsetest2.txt"))
print("Parse ValueError case 1 Failed!")
except ValueError:
print("Parse ValueError case 1 Passed!")
try:
parse(["Y"])
print("Parse Missing X Failed!")
except ValueError:
print("Parse Missing X Passed!")
try:
parse(["X"])
print("Parse Missing Y Failed!")
except ValueError:
print("Parse Missing Y Passed!")
try:
parse(["XY1"])
print("Parse Teleporter Pairs Failed!")
except ValueError:
print("Parse Teleporter Pairs Passed!")
def test_cells():
game = Game('board_hard.txt')
player = Player()
grid = game_parser.parse(game_parser.read_lines('board_hard.txt'))
## Testing cell.step() ##
cell = Start('X')
assert cell.step(game, player, grid,
'a') == '', 'cells testcase 1 failed, Start.step.'
cell = End('Y')
assert cell.step(
game, player, grid, 'a'
) == 'end of game - successful', 'cells testcase 2 failed, End.step.'
cell = Air(' ')
assert cell.step(game, player, grid,
'w') == '', 'cells testcase 3 failed, Air.step.'
cell = Wall('*')
assert cell.step(
game, player, grid, 's'
) == '\nYou walked into a wall. Oof!\n', 'cells testcase 4 failed, Wall.step.'
cell = Fire('F')
assert cell.step(
game, player, grid, 'd'
) == 'end of game - unsuccessful', 'cells testcase 5 failed, Fire.step with no water buckets.'
player.num_water_buckets = 1
assert cell.step(game, player, grid, 'a') == '\nWith your strong acorn arms, you throw a water bucket at the fire.' \
'You acorn roll your way through the extinguished flames!\n', 'cells testcase 6 failed, Fire.step with water bucket.'
cell = Water('W')
assert cell.step(
game, player, grid, 's'
) == "\nThank the Honourable Furious Forest, you've found a bucket of water!\n", 'cells testcase 7 failed, Water.step'
assert cell.step(
game, player, grid, 'a'
) == '', 'cells testcase 8 failed, Water.step should only function when stepped on for the first time.'
cell = Teleport('1')
assert cell.step(game, player, grid, 'a') == '\nWhoosh! The magical gates break Physics as we know ' \
'it and opens a wormhole through space and time.\n', 'cells testcase 9 failed, Teleport.step.'
def test_parse():
assert True
# positive cases
"""testing normal output of cells"""
grid = parse(["*XY"])
assert type(grid[0][0]) == type(Wall()), "Failed Parse!"
assert type(grid[0][1]) == type(Start()), "Failed Parse!"
assert type(grid[0][2]) == type(End()), "Failed Parse!"
"""testing normal output of cells"""
grid1 = ["*XY", "WF*", "11*"]
grid1p = parse(grid1)
assert type(grid1p[1][0]) == type(Water()), "Failed Parse!"
assert type(grid1p[1][1]) == type(Fire()), "Failed Parse!"
assert type(grid1p[1][2]) == type(Wall()), "Failed Parse!"
assert type(grid1p[2][0]) == type(Teleport(1)), "Failed Parse!"
assert type(grid1p[2][1]) == type(Teleport(1)), "Failed Parse!"
assert type(grid1p[2][2]) == type(Wall()), "Failed Parse!"
# negative cases
""" Type error for No file - readlines"""
try:
read_lines(None)
except TypeError:
pass
else:
print("Test Failed")
""" two start positions """
try:
grid1 = parse(["*XXY"])
except ValueError:
pass
else:
print("Test failed!")
""" two end positions """
try:
grid1 = parse(["*XYY"])
except ValueError:
pass
else:
print("Test failed!")
""" Single teleporter """
try:
grid1 = parse(["*XA1"])
except ValueError:
pass
else:
print("Test failed!")
""" Single teleporter2 """
try:
grid1 = parse(["*XA2"])
except ValueError:
pass
else:
print("Test failed!")
""" 3 teleporter """
try:
grid1 = parse(["*XA111"])
except ValueError:
pass
else:
print("Test failed!")
""" 0 teleporter """
try:
grid1 = parse(["*XA00"])
except ValueError:
pass
else:
print("Test failed!")
""" no start end or player """
try:
grid1 = parse(["***"])
except ValueError:
pass
else:
print("Test failed!")
""" 1cell """
try:
grid1 = parse(["*"])
except ValueError:
pass
else:
print("Test failed!")
""" only player """
try:
grid1 = parse(["*A"])
except ValueError:
pass
else:
print("Test failed!")
""" no start """
try:
grid1 = parse(["*Y"])
except ValueError:
pass
else:
print("Test failed!")
""" no end """
try:
grid1 = parse(["X*A"])
except ValueError:
pass
else:
print("Test failed!")
""" lowercase grid """
try:
grid1 = parse(["xyA"])
except ValueError:
pass
else:
print("Test failed!")
""" invalid character """
try:
grid1 = parse(["XYb"])
except ValueError:
pass
else:
print("Test failed!")
# edge cases
""" uneven lines of grid """
try:
grid1 = parse(["X*A", "Y11*"])
except ValueError:
pass
else:
print("Test failed!")
""" two cell grid """
grid1 = parse(["XY"])
assert type(grid1[0][0]) == type(Start()), "Failed Parse!"
assert type(grid1[0][1]) == type(End()), "Failed Parse!"
from game import Game
from player import Player
import game_parser
from grid import grid_to_string
import os
import sys
try:
filename = sys.argv[1]
except IndexError: ## Checking if a command line argument is given ##
print('Usage: python3 run.py <filename> [play]')
exit()
## Running the Game ##
try:
grid = game_parser.parse(game_parser.read_lines(filename))
player = Player()
Player.initial_player_position(player, grid)
board = grid_to_string(grid, player)
game = Game(filename)
print(board)
print()
except ValueError as e:
print(e)
exit()
while True:
player_input = input("Input a move: ")
#os.system('clear')
player_input = player_input.lower()
if player_input == 'q':
def read_lines_output(self, filename):
return read_lines(filename)
def main():
if len(sys.argv) < 2:
print("Usage: python3 run.py <filename> [play]")
sys.exit(0)
file = sys.argv[1]
game = Game(file)
# *** get grid ***
try:
grid = read_lines(game.filename)
except FileNotFoundError:
print(file + " does not exist!")
sys.exit(0)
# *** get coords ***
game_coords = game.collect_coords(grid)
# set player to start point
game.player.row = game_coords['X'][0][0]
game.player.col = game_coords['X'][0][1]
# display initial game board
game_view = game.read_cells(grid)
print(game_view)
# *** initialize important parameters ***
total_moves = 0
move_record = ''
result = 1 # 0 -> loss, 1 -> win
port_no = -1
while [game.player.row, game.player.col
] != game_coords['Y'][0]: # break when wins
cmd = input("Input a move: ").lower()
# read cmd
if cmd == 's':
will_move = game.game_move([1, 0])
elif cmd == 'w':
will_move = game.game_move([-1, 0])
elif cmd == 'a':
will_move = game.game_move([0, -1])
elif cmd == 'd':
will_move = game.game_move([0, 1])
elif cmd == 'q':
print("\nBye!")
sys.exit(0)
elif cmd == 'e':
will_move = game.game_move([0, 0])
else:
print(game_view)
print("Please enter a valid move (w, a, s, d, e, q).\n")
continue
# check if move is legal
item = search_coords(game_coords, will_move)
if item == '*' or item == -1:
print(game_view)
print("You walked into a wall. Oof!\n")
continue
elif item == 'W':
game.player.num_water_buckets += 1
elif item == 'F':
game.player.num_water_buckets -= 1
elif item in ['1', '2', '3', '4', '5', '6', '7', '8', '9']:
for coords in game_coords[item]:
if coords != will_move:
will_move = coords
break
# reset previous location
if port_no == -1:
grid[game.player.row][game.player.col] = ' '
else:
# port should be restored
grid[game.player.row][game.player.col] = str(port_no)
port_no = -1
# display start point
if game_coords['X']:
grid[game_coords['X'][0][0]][game_coords['X'][0][1]] = 'X'
else:
grid[game.player.row][game.player.col] = 'X'
# *** move the player ***
game.player.row = will_move[0]
game.player.col = will_move[1]
# update coords and view
game_coords = game.collect_coords(grid)
game_view = game.read_cells(grid)
print(game_view)
# record move numbers and details
total_moves += 1
move_record += cmd + ', '
# additional displayed message
if item == 'W':
print(
"Thank the Honourable Furious Forest, you've found a bucket of water!\n"
)
elif item == 'F':
if game.player.num_water_buckets < 0:
print(
"\nYou step into the fires and watch your dreams disappear :(.\n"
)
result = 0
break
print(
"With your strong acorn arms, you throw a water bucket at the fire. "
+ "You acorn roll your way through the extinguished flames!\n")
elif item in ['1', '2', '3', '4', '5', '6', '7', '8', '9']:
print(
"Whoosh! The magical gates break Physics as we know it and opens a wormhole through space and time.\n"
)
port_no = int(item)
if result == 1:
# Victory Hint
print(
"\nYou conquer the treacherous maze set up by the Fire Nation and reclaim the Honourable Furious Forest "
+ "Throne," +
" restoring your hometown back to its former glory of rainbow and sunshine! Peace reigns over the lands.\n"
)
else:
# Defeat Hint
print(
"The Fire Nation triumphs! The Honourable Furious Forest is reduced to a pile of ash "
+
"and is scattered to the winds by the next storm... You have been roasted.\n"
)
if total_moves == 1:
print("You made 1 move.")
print("Your move: " + move_record[:-2] + "\n")
else:
print("You made " + str(total_moves) + " moves.")
print("Your moves: " + move_record[:-2] + "\n")
if result == 1:
# Victory Hint
print("=====================\n"
"====== YOU WIN! =====\n"
"=====================")
else:
# Defeat Hint
print("=====================\n"
"===== GAME OVER =====\n"
"=====================")
def test_parse():
lines = read_lines('small_board.txt')
grid = parse(lines)
assert type(grid[0][0]) == Wall
assert type(grid[0][1]) == Start
assert type(grid[0][2]) == End
lines = read_lines('board_everything.txt')
grid = parse(lines)
assert type(grid[0][0]) == Wall
assert type(grid[0][1]) == Start
assert type(grid[0][2]) == Wall
assert type(grid[0][3]) == Wall
assert type(grid[1][0]) == Wall
assert type(grid[1][1]) == Water
assert type(grid[1][2]) == Fire
assert type(grid[1][3]) == Wall
assert type(grid[2][0]) == Wall
assert type(grid[2][1]) == Teleport
assert type(grid[2][2]) == Teleport
assert type(grid[2][3]) == Wall
assert type(grid[3][0]) == Wall
assert type(grid[3][1]) == Air
assert type(grid[3][2]) == Air
assert type(grid[3][3]) == Wall
assert type(grid[4][0]) == Wall
assert type(grid[4][1]) == End
assert type(grid[4][2]) == Wall
assert type(grid[4][3]) == Wall
## Negative test cases ##
''' Bad letter in configuration file '''
lines = read_lines('board_bad.txt')
try:
parse(lines)
assert False
except AssertionError:
print("parse: Testcase 1 failed (did not throw an exception)")
except ValueError:
pass
''' No ending position '''
lines = read_lines('board_noend.txt')
try:
parse(lines)
assert False
except AssertionError:
print("parse: Testcase 2 failed (did not throw an exception)")
except ValueError:
pass
''' No starting position '''
lines = read_lines('board_nostart.txt')
try:
parse(lines)
assert False
except AssertionError:
print("parse: Testcase 3 failed (did not throw an exception)")
except ValueError:
pass
''' Teleport pad with out matching pad '''
lines = read_lines('board_onepad.txt')
try:
parse(lines)
assert False
except AssertionError:
print("parse: Testcase 4 failed (did not throw an exception)")
except ValueError:
pass
for x in moves:
if x == ',' or x == ' ':
pass
else:
counter += 1
print('Path has {} moves.'.format(counter))
moves = moves[:-2]
print('Path: {}'.format(moves))
return True
return False
def solve(maze):
nums = []
add = ''
nums.append(add)
maze = parse(read_lines(filename))
while not find_end(maze, add):
add = nums[0]
nums.remove(nums[0])
for j in ["a", "d", "w", "s"]:
put = add + '{}, '.format(j)
if valid(maze, put):
nums.append(put)
return True
if __name__ == "__main__":
try:
maze = parse(read_lines(filename))
solution_found = solve(maze)
except IndexError:
print("There is no possible path.")
