def test_counting_4_center_cell_4_neighbours(self): world = World(3, 2) world.set([ [Cell(1), Cell(1), Cell(1)], [Cell(1), Cell(1), Cell(0)] ]) self.assertEqual(4, world.get_neighbourhoods()[0][1])
def test_counting_0_corner_cell_neighbours(self): world = World(2, 2) world.set([ [Cell(0), Cell(0)], [Cell(0), Cell(0)] ]) self.assertEqual(0, world.get_neighbourhoods()[0][0])
def test_that_death_cell_lives_with_3_alive_neighbours(self): world = World(2, 2) world.set([ [Cell(0), Cell(1)], [Cell(1), Cell(1)] ]) world.evolve() self.assertEqual(1, world.world[0][0].status)
def test_that_cell_keeps_death_4_alive_neighbours(self): world = World(3, 2) world.set([ [Cell(1), Cell(0), Cell(1)], [Cell(1), Cell(1), Cell(0)] ]) world.evolve() self.assertEqual(0, world.world[0][1].status)
def test_cell_dies(self): world = World(set([(1, 1)])) self.assertFalse(world.cell_lives((1, 1))) world.cells.add((1, 2)) self.assertFalse(world.cell_lives((1, 1))) world.cells.add((2, 2)) self.assertTrue(world.cell_lives((1, 1)))
def main(): world = World( Grid(3, [[False, False, False], [True, True, True], [False, False, False]])) for i in range(100): world.tick() for event in world.history: for row in event.display(): print(" ".join(row)) print("\n")
def test_tick_with_three_grid_with_horizontal_bar(self, three_grid_with_horizontal_bar): w = World(three_grid_with_horizontal_bar) w.tick() assert w.history[0] == three_grid_with_horizontal_bar expected_future = [ [Cell(False), Cell(True), Cell(False)], [Cell(False), Cell(True), Cell(False)], [Cell(False), Cell(True), Cell(False)] ] for y in range(2): for x in range(2): assert w.now.diagram[y][x].alive == expected_future[y][x].alive
class GameOfLife(Widget): def create_world(self): self.world = World(80, 60) self.world.generate() self.paint() def update(self, dt): self.world.evolve() self.paint() def paint(self): self.canvas.clear() with self.canvas: for x in range(self.world.width): for y in range(self.world.height): if self.world.world[y][x].status == 1: Rectangle(pos=(x*10, y*10), size=(10, 10))
def main(): parser = argparse.ArgumentParser() parser.add_argument('players', nargs='+') parser.add_argument('--seed', type=int, default=None) parser.add_argument('-o', '--output', type=argparse.FileType('w'), default=sys.stdout) parser.add_argument('-m', '--map', choices=['empty', 'blocks', 'cave'], default='empty') parser.add_argument('--long', action='store_true') args = parser.parse_args() bots = [] for player in args.players: with open(player, 'r') as f: code = f.read().strip() parsed = [] for i in range(0, len(code), 4): if i + 4 <= len(code): parsed.append(int(code[i:i + 4], 16)) bots.append(parsed) map_generator = map.Map if args.map == 'empty' \ else map.RocksMap if args.map == 'blocks' \ else map.CaveMap world = World(bots, map_generator, args.seed) if args.long: World.ENERGY_PER_TURN = 1000 World.STARTING_ENERGY = 1000000 meta = { 'players': args.players, 'seed': args.seed if args.seed is not None else -1, 'map': args.map } args.output.write(world.run_with_log(1000, meta))
def do_action(action): s = World.player r = -World.score if action == actions[0]: World.try_move(0, -1) elif action == actions[1]: World.try_move(0, 1) elif action == actions[2]: World.try_move(-1, 0) elif action == actions[3]: World.try_move(1, 0) else: return s2 = World.player r += World.score return s, action, r, s2
def startWorld(hosting): name, ip, port = nameField.get(), ipField.get(), int(portField.get()) startFrame.destroy() log = open( time.strftime('LOG-' + ('server' if hosting else 'client') + '-%Y.%m.%d.%H.%M.%S.txt'), 'w') try: World(hosting, name, ip, port, log=log) except: print 'Unexpected Error', sys.exc_info() log.write('#ERROR:' + str(sys.exc_info()) + '/n') log.flush() sys.exit() log.flush()
def __init__(self, num_states=(2 * 4) * (2 * 4) * 2, num_actions=5, alpha=1.0, alpha_decay=0.99996, gamma=0.9, epsilon=1.0, epsilon_decay=0.99996, max_steps_per_episode=1000, max_num_episodes=1000000, save_model_per=1000000, verbose=False): self.world = World() self.game = Play_game() # inputs self.alpha = alpha self.alpha_decay = alpha_decay self.gamma = gamma self.epsilon = epsilon self.epsilon_decay = epsilon_decay self.max_steps_per_episode = max_steps_per_episode self.max_num_episodes = max_num_episodes self.save_model_per = save_model_per # initialize self.num_states = num_states # 4x2 grid, two players, with or without ball self.num_actions = num_actions self.q_table = np.full(shape=(num_states, num_actions), fill_value=1.0) self.q_tables = { 'A': deepcopy(self.q_table), 'B': deepcopy(self.q_table) } self.state = {} self.actions = { 'A': 0, 'B': 0 } # map N, S, E, W, and stick to [0,1,2,3,4] # error self.ERRs = [] self.steps_to_plot = [] self.verbose = verbose
class GameHandler(EventHandler): def __init__(self): """ init the world """ self.world = World() self.world.draw() def on_key_down(self, key): """ on key down handler """ def on_key_pressed(self, keys): self.world.main_character.downward = keys[pygame.K_DOWN] or keys[ pygame.K_s] self.world.main_character.upward = keys[pygame.K_UP] or keys[ pygame.K_w] self.world.main_character.rightward = keys[pygame.K_RIGHT] or keys[ pygame.K_d] self.world.main_character.leftward = keys[pygame.K_LEFT] or keys[ pygame.K_a] return keys[pygame.K_DOWN] or keys[pygame.K_s] or keys[ pygame.K_UP] or keys[pygame.K_w] or keys[pygame.K_RIGHT] or keys[ pygame.K_d] or keys[pygame.K_LEFT] or keys[pygame.K_a] def on_mouse_click(self, *point): """ on mouse click handler """ def update(self, changed): """ update world handler """ self.world.update() self.world.draw()
actions = World.actions states = [] Q = {} E = {} for i in range(World.x): for j in range(World.y): states.append((i, j)) for state in states: temp = {} temp_e = {} for action in actions: temp[action] = 0.0 # Set to 0.1 if following greedy policy temp_e[action] = 0.0 World.set_cell_score(state, action, temp[action]) Q[state] = temp E[state] = temp_e for (i, j, c, w) in World.specials: for action in actions: Q[(i, j)][action] = w World.set_cell_score((i, j), action, w) def do_action(action): s = World.player r = -World.score if action == actions[0]: World.try_move(0, -1) elif action == actions[1]:
def test_can_set_initial_state(self): seed = set([(1, 2), (2, 3), (5, 7)]) world = World(seed) self.assertTrue(world.cell_at((1, 2))) self.assertFalse(world.cell_at((1, 7)))
lives_text = BitmapText( font_2, [Game.screen_width - 200, 50] ) lives_text.setSurface( screen ) gameover_text = BitmapText( font_1, [(Game.screen_width / 2)-300, 100] ) gameover_text.setSurface( screen ) dead_text = BitmapText( font_2, [(Game.screen_width / 2)-50, 100] ) dead_text.setSurface( screen ) restart_text = BitmapText( font_2, [(Game.screen_width / 2)-200, 200] ) restart_text.setSurface( screen ) Game.level = 1 world = World( ) player = Player( ) pygame.mouse.set_visible( False ) # Define core colours black = ( 0, 0, 0 ) white = ( 255, 255, 255 ) red = ( 255, 0, 0 ) green = ( 0, 255, 0 ) blue = ( 0, 0, 255 ) # Create clock clock = pygame.time.Clock( ) # Main Program Loop flag
def test_that_worlds_get_created_with_expected_size(self): world = World(10, 10) world.generate() self.assertEqual(10, len(world.world)) self.assertEqual(10, len(world.world[0]))
def __init__(self): """ init the world """ self.world = World() self.world.draw()
def run(): global discount global epsilon global alpha global log score = 0 time.sleep(1) s1 = World.player a1, q_val1 = policy(s1) for episode_num in range(40): steps = 0 score = 0 while not World.has_restarted(): # Do the action (s1, a1, r1, s2) = do_action(a1) score += r1 # Update Q a2, q_val2 = policy( s2) # Change to max_Q(s2) if following Greedy policy a_best, q_best = max_Q(s2) delta = r1 + discount * q_best - Q[s1][a1] E[s1][a1] = 1 for state in states: for action in actions: inc_Q(state, action, alpha, delta) if a_best == a2: E[state][action] *= discount * e_decay else: E[state][action] = 0 # print('new q:', Q[s1][a1]) s1 = s2 a1 = a2 q_val1 = q_val2 steps += 1 # Update the learning rate # MODIFY THIS SLEEP IF THE GAME IS GOING TOO FAST. # time.sleep(0.005) World.restart_game() reset_E() log.append({ 'episode': episode_num, 'score': score, 'steps': steps, 'alpha': alpha, 'epsilon': 0 }) # time.sleep(0.01) alpha = max(0.1, pow(episode_num + 1, -0.4)) epsilon = min(0.3, pow(episode_num + 1, -1.2)) with open('data/Q.csv', 'w', newline='') as csvfile: writer = csv.DictWriter( csvfile, fieldnames=['episode', 'score', 'steps', 'alpha', 'epsilon']) writer.writeheader() for episode in log: writer.writerow(episode) print('Logged')
def inc_Q(s, a, alpha, inc): Q[s][a] += alpha * inc * E[s][a] World.set_cell_score(s, a, Q[s][a])
def test_can_count_neighbors(self): world = World(set([(1, 1), (2, 1), (1, 2), (2, 2), (5, 5)])) self.assertEqual(len(world.neighbors_at((1, 1))), 3)
def create_world(self): self.world = World(80, 60) self.world.generate() self.paint()
clients and clients[0].broadcast(clients, make_msg('world', world.dump_world())) def reset_world(world, clients): log.info('Reseting world at age: {0}'.format(world.age)) world.reset_world() for client in clients: client.send(make_msg('world', world.dump_world())) handlers = [ (r'/', IndexHandler), (r'/static/(.*)', web.StaticFileHandler, { 'path': './static/' }), ] + SockJSRouter(SocketHandler, '/ws').urls if __name__ == '__main__': app = web.Application(handlers, debug=True, autoreload=True) port = 8888 app.listen(port) loop = ioloop.IOLoop.instance() world = World(width=width, height=height, alive_cells=SIMPLE_PLANER) log.info('Starting world at age {0}, listening at {1}'.format( world.age, port)) period_cbk = ioloop.PeriodicCallback(partial(evolve_world, world, clients), 250, loop) period_cbk.start() loop.start()