def compare_q_learning_sarsa(list_maps):
param = [("max first", max_first, 'default'),
("Explore : softmax", explore, 'softmax'),
('Explore-exploitation : softmax', explore_exploitation,
'softmax')]
for name_map, number_episodes in list_maps:
game_map = Map(name_map)
for p in param:
_, _, _, _, q_values_q, number_q = q_learning(
game_map=game_map,
training_episode=number_episodes,
epsilon_greedy=p[1],
strategy=p[2])
_, _, _, _, q_values_sarsa, number_sarsa = sarsa(
game_map=game_map,
training_episode=number_episodes,
epsilon_greedy=p[1],
strategy=p[2])
plt.clf()
fig = plt.figure()
plt.plot(range(1,
len(q_values_q) + 1),
q_values_q,
color='green',
label='Q-Learning')
plt.plot(range(1,
len(q_values_sarsa) + 1),
q_values_sarsa,
color='red',
label="SARSA")
plt.title("Evolution q values : " + p[0] + " Map : " +
name_map.split('/')[-1].split('.')[0])
plt.xlabel("Number episodes")
plt.ylabel("Mean Q Values")
plt.legend()
plt.savefig('plot/Q_Learning_vs_SARSA_Value_' + p[0] + '_' +
name_map.split('/')[-1].split('.')[0] + '.png')
plt.clf()
fig = plt.figure()
plt.plot(range(1,
len(number_q) + 1),
number_q,
color='yellow',
label='Q-Learning')
plt.plot(range(1,
len(number_sarsa) + 1),
number_sarsa,
color='blue',
label='SARSA')
plt.title("Len Q " + p[0] + " Map : " +
name_map.split('/')[-1].split('.')[0])
plt.xlabel("Number episodes")
plt.ylabel("Len Q")
plt.legend()
plt.savefig('plot/Q_Learning_vs_SARSA_Len_' + p[0] + '_' +
name_map.split('/')[-1].split('.')[0] + '.png')
def load(self, saveFile):
"""
Loads the game from a save file, creates an empty game if the save is None
"""
save = json.load(open(saveFile, "r"))
self.map = Map(save['map'])
self.player = Player(save['player'])
def test_map_init():
maze = Map('classic')
assert maze.map_matrix.shape == (22, 19)
assert maze.map_matrix.min() == 10
assert maze.map_matrix.max() == 50
assert maze.map_matrix.dtype == int64
assert maze.map_matrix[16][9] == 40
def __init__(self, screen, player, room_id=0):
MapState.__init__(self, screen, player)
# TODO init room settings from room_data with room_id
self.set_map(Map(CONFIG['room_data'][room_id]['bg_file']))
test2 = UnitEntity(0)
test2.set_unit_group(2)
test1 = UnitEntity(0)
test1.set_unit_group(2)
test3 = UnitEntity(0)
test3.set_unit_group(2)
test4 = UnitEntity(0)
test4.set_unit_group(2)
self.add_entity_to_map(test2, 6, 6)
self.add_entity_to_map(test1, 5, 5)
self.add_entity_to_map(test3, 12, 12)
self.add_entity_to_map(test4, 14, 14)
#self.p1.bind_entity(test2)
self.set_follow_camera(test1)
#self.i_state = InventoryState(self.screen, self.p1, self)
self._force_draw()
def _create_test_map(self):
self.map = Map(TEST_MAP)
for row, tiles in enumerate(self.map.get_data):
for column, tile in enumerate(tiles):
if tile == "1":
t = StaticTile(Vector2(column, row),
self.image_manager.get_image("grass"))
self.nature_tiles.add(t)
self.visible_sprites.add(t, layer=0)
if tile == "0":
t = StaticTile(Vector2(column, row),
self.image_manager.get_image("water"))
self.nature_tiles.add(t)
self.visible_sprites.add(t, layer=0)
if tile == "8":
t = StaticTile(Vector2(column, row),
self.image_manager.get_image("grass"))
self.nature_tiles.add(t)
self.visible_sprites.add(t, layer=0)
t = MovableTile(Vector2(column, row),
self.image_manager.get_image("farmer"))
self.player1_units.add(t)
self.visible_sprites.add(t, layer=2)
if tile == "9":
# TODO: Remove double sprite on one coordinate
t = StaticTile(Vector2(column, row),
self.image_manager.get_image("grass"))
self.nature_tiles.add(t)
self.visible_sprites.add(t, layer=0)
t = Tile(Vector2(column, row),
self.image_manager.get_image("village"))
self.player1_villages.add(t)
self.visible_sprites.add(t, layer=1)
def test_get_rba_array():
maze = Map('classic')
g = Game(maze=maze,
screen=pg.display.set_mode(maze.get_map_sizes()),
sounds_active=False,
state_active=False)
arr = g.get_rba_array()
assert type(arr) is np.ndarray
assert arr.shape == (456, 552, 3)
def __init__(self):
# Initialize surface, backgorund
self.surface = pygame.display.set_mode(RESOLUTION, 0, 32)
pygame.display.set_caption('Oil Spill Simulation')
self.background = pygame.Surface(RESOLUTION)
self.background.fill(LIGHTBLUE)
# Initialize manager for buttons
self.manager = pygame_gui.UIManager(RESOLUTION)
# Initialize Menu buttons
self.startButton = pygame_gui.elements.UIButton(
relative_rect=pygame.Rect(POSITION_STARTBUTTON, SIZE_STARTBUTTON),
text='START',
manager=self.manager)
self.resetButton = pygame_gui.elements.UIButton(
relative_rect=pygame.Rect(POSITION_RESETBUTTON, SIZE_RESETBUTTON),
text='RESET',
manager=self.manager)
self.documentationButton = pygame_gui.elements.UIButton(
relative_rect=pygame.Rect(POSITION_DOCUMENTATIONBUTTON,
SIZE_DOCUMENTATIONBUTTON),
text='Documentation',
manager=self.manager)
# Initlialize labels
self.titleLablel = pygame_gui.elements.UIButton(
relative_rect=pygame.Rect(POSITION_TITLELABEL, SIZE_TITLELABEL),
text='DEEPWATER HORIZON OIL SPILL SIMULATION',
manager=self.manager,
tool_tip_text=
"This is a simulation of DeepWater Horizon Oil Spill by Zuzanna Smiech and Mikolaj Ogarek."
)
self.timeLabel = pygame_gui.elements.UILabel(relative_rect=pygame.Rect(
POSITION_TIMELABEL, SIZE_TIMELABEL),
text='Time[h]: 0.0',
manager=self.manager)
# Initialize map
self.map = Map()
# Initialize oil points list hardcoded values 100t of oil, start coords
self.oil_point_list = DiscretizedOil(TOTAL_WEIGHT,
NUMBER_OF_OIL_POINTS,
(X_START, Y_START))
# at the begining all oil poitns are in start cell
self.map.simulationArray[X_START][
Y_START].oil_points = self.oil_point_list.oil_points_array[:] #.copy()
self.total_time = 0
self.total_oil_mass = TOTAL_WEIGHT
self.nc = netCDF4.Dataset("src/daily_currents.nc")
self.update_wind_and_currents(0)
self.step = 0
def __init__(self):
bit_map = assets.generate_map()
super().__init__(bit_map.shape[1] * settings.BLOCK_SIZE,
bit_map.shape[0] * settings.BLOCK_SIZE +
settings.BLOCK_SIZE * 3,
"PAC-MAN",
resizable=False)
self.map = Map(bit_map)
self.event_loop = pyglet.app.EventLoop()
pyglet.clock.schedule_interval(self.update, 1 / 120.0)
def __init__(self, levelname: str, world: esper.World):
super().__init__()
self.scene = self
self.map: Map = Map(settings.BASE_DIR + "\\" + levelname)
self.camera: Camera = Camera()
self.entities = []
self.player = world.create_entity()
self.world = world
self.player: Player = Player(world, player_name="ShuzZzle")
self.player.create((Velocity(velx=10, vely=10), Position(x=0, y=0)))
def A_star_test(path):
i_start = 1
j_start = 1
i_goal = 13
j_goal = 28
width, height, cell = read_map_from_moving_ai_file(path)
task_map = Map()
task_map.set_grid_cells(width, height, cell)
print(A_star(task_map, i_start, j_start, i_goal, j_goal, []))
print(A_star(task_map, i_start, j_start, i_goal, j_goal, [((2, 1), 1)]))
print(A_star(task_map, i_start, j_start, i_goal, j_goal, [((1, 1), 0)]))
def __init__(self, network):
"""
Set up display and game map.
Arguments:
network {Network} -- Connection to server
"""
pygame.init()
# Connection to the server
self.network = network
self.player_num = self.network.get_player_num()
print("You are player", self.player_num)
# Set up display window
pygame.display.set_caption("A Game of Shapes - Player " +
str(self.player_num))
screen_res = (WINDOW_WIDTH, WINDOW_HEIGHT)
self.screen = pygame.display.set_mode(screen_res)
# Set up font
pygame.font.init()
self.game_font = pygame.font.Font(GAME_FONT, 40)
# Set up gameplay map
self.map = Map(self.screen, self.player_num, self.network)
# Represents the state of game
# Modified by server and sent to clients
self.gamestate = self.network.get_gamestate()
is_turn = self.gamestate.is_players_turn(self.player_num)
# Effects of turn that are sent across network
self.turn = {
"move": None,
"attack": None,
"phase": NOT_TURN,
"result": None
}
# Let the starting player begin moving units
if is_turn:
self.turn["phase"] = SELECT_UNIT_TO_MOVE
# Clock tracks time from beginning of game
self.clock = pygame.time.Clock()
# Keep track of user's cursor. Updates every frame
self.mouse_position = pygame.mouse.get_pos()
# Show waiting screen until other player connects
self.waiting_screen()
# Start the game
self.game_loop()
def test_init_cell_instance_correctess(self):
# black magic
input = ['S.#', 'GET']
expected = [
[self.SpawnMock, self.EmptyCellMock, self.WallMock],
[self.GatewayMock, self.EmptyCellMock, self.EmptyCellMock]]
Map(input)
for row, mocks in zip(range(2), expected):
for col, ctor_mock in zip(range(3), mocks):
all_kwargs = [kwargs for args, kwargs in ctor_mock.call_args_list]
self.assertIn({'row': row, 'col': col}, all_kwargs)
def compare_max_first_random(list_maps):
for name_map, number_episodes in list_maps:
game_map = Map(name_map)
_, _, _, _, q_values_max, number_visited_max = q_learning(
game_map=game_map,
epsilon_greedy=max_first,
training_episode=number_episodes)
_, _, _, _, q_values_random, number_visited_random = q_learning(
game_map=game_map,
epsilon_greedy=random_choice_action,
training_episode=number_episodes)
plt.clf()
fig = plt.figure()
plt.plot(range(1,
len(q_values_max) + 1),
q_values_max,
color='yellow',
label='Max Fist')
plt.plot(range(1,
len(q_values_random) + 1),
q_values_random,
color='blue',
label="Random")
plt.title("Evolution q values, Map : " +
name_map.split('/')[-1].split('.')[0])
plt.xlabel("Number episodes")
plt.ylabel("Mean Q Values")
plt.legend()
plt.savefig('plot/Evolution_q_values_Map_' +
name_map.split('/')[-1].split('.')[0] + '.png')
plt.clf()
fig = plt.figure()
plt.plot(range(1,
len(number_visited_max) + 1),
number_visited_max,
color='yellow',
label='Max Fist')
plt.plot(range(1,
len(number_visited_random) + 1),
number_visited_random,
color='blue',
label='Random')
plt.title("Len Q, Map : " + name_map.split('/')[-1].split('.')[0])
plt.xlabel("Number episodes")
plt.ylabel("Len Q")
plt.legend()
plt.savefig('plot/Len_Q_Map_' +
name_map.split('/')[-1].split('.')[0] + '.png')
def eval_score_max_first(list_maps):
for name_map, number_episodes in list_maps:
game_map = Map(name_map)
_, _, _, _, q_values, _ = q_learning(
game_map=game_map,
epsilon_greedy=max_first,
training_episode=number_episodes)
plt.clf()
fig = plt.figure()
plt.plot(range(1, len(q_values) + 1), q_values)
plt.title("Max Fist : evolution q values Map : " +
name_map.split('/')[-1].split('.')[0])
plt.xlabel("Number episodes")
plt.ylabel("Mean Q Values")
plt.savefig('plot/Max_Fist_evolution_q_values_Map_' +
name_map.split('/')[-1].split('.')[0] + '.png')
def __init__(self, width: int, height: int):
"""
:param width: width in pixels
:param height: height in pixels
"""
# Global app window
self.root = Tk()
self.root.geometry("400x600")
# labels and size
self.width = width
self.height = height
self.main_label = Label(self.root)
self.main_label.pack(pady=80)
self.frame = Frame(self.root)
self.scrollbar = Scrollbar(self.frame, orient=VERTICAL)
self.listbox = Listbox(self.frame,
width=50,
yscrollcommand=self.scrollbar.set,
selectmode=MULTIPLE)
self.vehicles = Entry(self.root)
self.vehicles.pack()
self.vehicles.insert(0, "Number of vehicles:")
# buttons
self.open_from_file_button = Button(
self.root,
text="OPEN FROM FILE",
command=self.open_from_file_on_click_listener)
self.open_from_file_button.pack(pady=10)
self.show_button = Button(self.root,
text="SHOW MAP",
command=self.show_on_click_listener)
self.show_button.pack(pady=10)
self.find_routes_button = Button(
self.root,
text="FIND ROUTES",
command=self.find_routes_on_click_listener)
self.find_routes_button.pack(pady=10)
# data frame
self.cities_df = pd.DataFrame()
self.connections = []
# optimizer parameters
self.number_of_vehicles = 1
# map object
self.map = Map()
def test_init_home():
p = Pacman()
maze = Map('classic')
home_x, home_y = maze.get_player_home()
p.init_home(home_x, home_y)
assert p.home_x == 9
assert p.home_y == 16
assert p.x == p.home_x * TILE_SIZE
assert p.y == p.home_y * TILE_SIZE
assert p.nearest_col == p.home_x
assert p.nearest_row == p.home_y
p.init_home(0, 0)
assert p.home_x == 9
assert p.home_y == 16
assert p.x == p.home_x * TILE_SIZE
assert p.y == p.home_y * TILE_SIZE
assert p.nearest_col == p.home_x
assert p.nearest_row == p.home_y
def test_hyperparameter(args):
name_map, number_episodes, name_epsilon_greedy, epsilon_greedy, strategy = args
learning_rates = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
discovering_factors = [0.9, 0.85, 0.8, 0.75, 0.7, 0.65, 0.5]
game_map = Map(name_map)
hearder_table = [
"D.F. / L.R.", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7"
]
win_ant = []
win_eval = []
for discovering_factor in discovering_factors:
w_ant = [discovering_factor]
w_eval = [discovering_factor]
for learning_rate in learning_rates:
Q = {}
Q, _, _, win_games, _, _ = q_learning(
Q=Q,
game_map=game_map,
training_episode=number_episodes,
epsilon_greedy=epsilon_greedy,
strategy=strategy,
learning_rate=learning_rate,
discovering_factor=discovering_factor)
w_ant.append(round(win_games, 4))
w_eval.append(
round(Eval.run_games(Q, game_map, number_episodes), 2))
win_ant.append(w_ant)
win_eval.append(w_eval)
df1 = pd.DataFrame(win_ant, columns=hearder_table)
df1.to_excel("xlsx/Hyperparameters_{}_{}_Training.xlsx".format(
name_epsilon_greedy,
name_map.split('/')[-1].split('.')[0]))
df2 = pd.DataFrame(win_eval, columns=hearder_table)
df2.to_excel("xlsx/Hyperparameters_{}_{}_Evaluation.xlsx".format(
name_epsilon_greedy,
name_map.split('/')[-1].split('.')[0]))
def __init__(self, map_file, config_file):
super().__init__(resizable=True,
caption='Tourism Simulation',
visible=False)
self.set_minimum_size(640, 480)
self.set_maximum_size(2260, 3540)
self.frame_rate = 1 / 60.0 # Target frame-rate, usually can't keep up
self.icon1 = pyglet.image.load('./graphics/Icon1.png')
self.icon2 = pyglet.image.load('./graphics/Icon2.png')
self.set_icon(self.icon1, self.icon2)
self.map = Map(self.width, self.height, map_file)
self.set_visible(True)
self.x = 800
self.y = -800
self.simulation = Simulation(2260, 3540, self.width, self.height,
config_file)
def test_update_ghosts_positions():
maze = Map('classic')
ghosts = [Ghost(i, (255, 0, 0, 255)) for i in range(4)]
def get_random_allow_position() -> Tuple[int, int]:
res = np.where(maze.state_matrix == 1)
rnd = np.random.randint(0, high=len(res[0]))
return res[1][rnd], res[0][rnd]
rand_pos = []
for ghost in ghosts:
x, y = get_random_allow_position()
rand_pos.append((x, y))
ghost.nearest_col = x
ghost.nearest_row = y
maze.update_ghosts_position(ghosts)
for x, y in rand_pos:
assert maze.state_matrix[y][x] == -1
def __init__(self, screen_w = 800, screen_h = 600):
pygame.init()
self.screen_w = screen_w
self.screen_h = screen_h
# Cursor handling
self.visible = False
self.esc = False
pygame.mouse.set_visible(self.visible)
pygame.event.set_grab(not self.visible)
pygame.mouse.set_pos((screen_w / 2, screen_h / 2))
# Initialize camera
self.camera = Camera()
self.camera.set_pos(Vec3(0, 0, -32)) # Set far away to help performance
self.renderer = Renderer(screen_w, screen_h)
# Only generate cube mesh once
self.cube = Cube()
# Load images and define grass block
self.media = {
"grass_block_side": pygame.image.load("media/grass_block_side.png"),
"grass": pygame.image.load("media/grass.png"),
"dirt": pygame.image.load("media/dirt.png")
}
self.texture = [
self.media["grass_block_side"],
self.media["grass_block_side"],
self.media["grass_block_side"],
self.media["grass_block_side"],
self.media["grass"],
self.media["dirt"]
]
self.map = Map(8, False) # Change False to True for testing mode
def plot_score(list_maps):
param = [("random", random_choice_action, "default"),
("max first", max_first, 'default'),
("Explore : default", explore, 'default'),
("Explore : softmax", explore, 'softmax'),
("Explore : uct", explore, 'uct'),
('Explore-exploitation : default', explore_exploitation,
'default'),
('Explore-exploitation : softmax', explore_exploitation,
'softmax')]
for name_map, number_episodes in list_maps:
game_map = Map(name_map)
for p in param:
_, train_scores, eval_scores, _, _, _ = q_learning(
game_map=game_map,
training_episode=number_episodes,
epsilon_greedy=p[1],
strategy=p[2])
plt.clf()
fig = plt.figure()
plt.plot(np.linspace(1, len(train_scores), len(train_scores)),
np.convolve(train_scores, [0.2, 0.2, 0.2, 0.2, 0.2],
"same"),
linewidth=1.0,
color="blue",
label='Training')
plt.plot(np.linspace(10, len(train_scores), len(eval_scores)),
eval_scores,
linewidth=2.0,
color="red",
label='Evaluation')
plt.title("Score evolution: " + p[0] + " Map " + name_map)
plt.ylabel("Average score")
plt.xlabel("Episode")
plt.legend()
plt.savefig("plot/" + "Score_evolution" + p[0] + "_Map_" +
name_map.split('/')[-1].split('.')[0] + ".png")
def __init__(self,
layout: str,
enable_render=True,
state_active=False,
player_lives: int = 3):
"""
PacmanEnv constructor
:param layout: the layout of the game
:param frame_to_skip: the frame to skip during training
:param enable_render: enabling the display of the game screen
:param state_active: enabling the display of the state matrix
"""
self.layout = layout
self.state_active = state_active
self.enable_render = enable_render
if enable_render:
pg.init()
self.action_space = spaces.Discrete(Action.__len__())
self.maze = Map(layout)
self.width, self.height = self.maze.get_map_sizes()
self.game = Game(
maze=self.maze,
screen=Controller.get_screen(state_active, self.width, self.height)
if enable_render else None,
sounds_active=False,
state_active=state_active,
agent=None)
self.timer = 0
self.reinit_game = False
self.player_lives = player_lives
self.observation_space = spaces.Space(
shape=self.get_screen_rgb_array().shape, dtype=int)
self.seed()
def gen_tileset_map(self, tileset_id):
filename = CONFIG['tile_configs']['tilesets'][tileset_id]['filename']
rm.load_tileset_by_id(tileset_id)
testmap = Map()
testmap.empty_map()
x = 0
y = 0
count = 0
for tileconfig in rm.tilesets[filename]:
if y >= CONFIG['tool_tileviewer_max_col_size']:
x += 1
y = 0
tile = Tile(0)
tile.tileset_id = tileset_id
tile.tile_id = count
if x not in testmap.tiles:
testmap.tiles.append([])
testmap.tiles[x].append(tile)
y += 1
count += 1
return testmap
import os
import sys
sys.path.append(os.path.abspath(__file__ + "../../.."))
from src.utils import next_game, open_file
from src.map import Map
if __name__ == "__main__":
while True:
first_step = input(
"How do you want to give map me? File(1) or Keyboard(2)? ")
treasure = Map()
if first_step == "1":
print("Please provide me the path to the file ")
fl_name = sys.stdin.readline().strip()
rows = open_file(fl_name)
treasure.from_file(rows)
treasure.hunt_treasure()
elif first_step == "2":
print(
"Please enter 25 numbers (each of them should be between 11 and 55) "
)
treasure.from_keyboard()
treasure.hunt_treasure()
if not next_game():
break
def main_loop(clock, player_plane, renderables, screen, mixer):
"""All game logic goes here
:param clock:
:param player_plane:
:param renderables:
:param screen:
:param text:
:return: True if user wants to restart, False otherwise
"""
# Loop until the user clicks the close button.
done = False
restart = False
last_update = 0
_map = Map(renderables)
mixer.play_music()
text_to_render = "instructions"
# -------- Main Program Loop -----------
while not done:
check_collisions(renderables, mixer)
# --- Main event loop
for event in pygame.event.get(): # User did something
# If user clicked close
if event.type == pygame.QUIT:
# Flag that we are done so we exit this loop
done = True
continue;
# Reset player plane's sprite
if event.type == pygame.KEYUP:
player_plane.reset_sprite()
player_plane.reset_weapon_cooldown()
continue;
enemy_planes = renderables.get_sprites_from_layer(Layer.ENEMIES)
for idx, enemy_plane in enumerate(enemy_planes):
if event.type == pygame.USEREVENT + idx:
bullet = enemy_plane.fire()
mixer.play_sound('enemy_bullet')
renderables.add(bullet, layer=Layer.ENEMY_BULLETS)
mixer.handle_event(event)
# Get user's key presses
pressed = pygame.key.get_pressed()
# 'q' quits the application
if pressed[pygame.K_q]:
done = True
if pressed[pygame.K_r]:
restart = True
done = True
# Arrows move the player's plane
else:
# If the player is still in the game
if renderables.get_sprites_from_layer(Layer.PLAYER):
# Move right
if pressed[pygame.K_RIGHT]:
player_plane.move_right()
# More left
if pressed[pygame.K_LEFT]:
player_plane.move_left()
# Move up
if pressed[pygame.K_UP]:
player_plane.move_up()
# Move down
if pressed[pygame.K_DOWN]:
player_plane.move_down()
# Fire
if pressed[pygame.K_SPACE]:
# Create bullet
bullet = player_plane.fire()
if isinstance(bullet, Bullet):
mixer.play_sound('player_bullet')
renderables.add(bullet, layer=Layer.PLAYER_BULLETS)
else:
mixer.stop_music()
text_to_render = "game_over,restart"
# Update all sprites in the main sprite group
renderables.update()
# Clear Screen
screen.fill(Constants.WHITE)
# Draw all sprites
renderables.draw(screen)
draw_text(screen, render=text_to_render)
# Refresh Screen
pygame.display.flip()
now = pygame.time.get_ticks()
if now - last_update >= Constants.UPDATE_INTERVAL and not _map.active:
last_update = now
text_to_render = None
try:
_map.start()
horde = _map.next_horde()
horde.activate()
except LevelFinished:
_map.pause()
if _map.active and now - last_update >= horde.interval:
last_update = now
try:
horde.render_line()
except FormationEnd:
_map.pause()
# Number of frames per second
# 30fps generate flickering. Going with 60
clock.tick(60)
if restart:
return True
return False
def test_hunt_treasure_oop_negative():
maps = Map()
with patch('builtins.input', side_effect=INPUT_WITHOUT_TREASURE):
maps.from_keyboard()
maps.hunt_treasure()
assert maps.message == "This map has not treasure"
def test_hunt_treasure_oop():
maps = Map()
with patch('builtins.input', side_effect=INPUT_WITH_TREASURE):
maps.from_keyboard()
maps.hunt_treasure()
assert maps.hunt_treasure() == OUTPUT_TREASURE
def test_from_keyboard_oop():
maps = Map()
with patch('builtins.input', side_effect=FILE):
maps.from_keyboard()
for i in range(5):
assert len(maps.grid[i]) == 5
def test_from_file_oop():
maps = Map()
maps.from_file(FILE)
for i in range(5):
assert len(maps.grid[i]) == 5
from src.constants import PATH_FINDER_LOOKUP_TABLE
from src.map import Map
from src.utils.functions import get_neighbors
maze = Map('test')
matrix = maze.matrix_from_lookup_table(PATH_FINDER_LOOKUP_TABLE)
def test_neighbors_inside_map():
neighbors = get_neighbors(matrix, 16, 9)
assert neighbors['R'].value == 0
assert neighbors['L'].value == 0
assert neighbors['U'].value == 100
assert neighbors['D'].value == 100
def test_neighbors_left_upper_angle():
neighbors = get_neighbors(matrix, 0, 0)
assert neighbors['R'].value == 100
assert neighbors['L'] is None
assert neighbors['U'] is None
assert neighbors['D'].value == 100
def test_neighbors_right_upper_angle():
neighbors = get_neighbors(matrix, 0, matrix.shape[1] - 1)
assert neighbors['R'] is None
assert neighbors['L'].value == 100
assert neighbors['U'] is None
assert neighbors['D'].value == 100