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
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
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 __init__(self):
"""
init the world
"""
self.world = World()
self.world.draw()
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()
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)))
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)
