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