def parse_args(args): return utils.structify({ "action": utils.get(args, str, "list", ["action"]), "agents": utils.get(args, list, [], ["agents"]), "configuration": utils.get(args, dict, {}, ["configuration"]), "environment": args.get("environment", None), "episodes": utils.get(args, int, 1, ["episodes"]), "state": utils.get(args, dict, {}, ["state"]), "steps": utils.get(args, list, [], ["steps"]), "render": utils.get(args, dict, {"mode": "json"}, ["render"]), "debug": utils.get(args, bool, False, ["debug"]), "timeout": utils.get(args, int, 10, ["timeout"]), "host": utils.get(args, str, "127.0.0.1", ["host"]), "port": utils.get(args, int, 8000, ["port"]), "use_subprocess": utils.get(args, bool, True, ["subprocess-agents"]) })
def load_latest_ship_attr(mainattr='ships', attr='halite'): match, config = load_latest() record = {} for pid in range(4): record[pid] = {} for step in range(400): state = match['steps'][step][0] # list of length 1 for each step obs = state['observation'] # these are observations at this step for pid in range(4): qps = get_quadrant_points(pid) obs['player'] = pid # change the player to the one we want to inspect precord = record[pid] obs = structify( obs) # turn the dict's into structures with attributes b = Board(obs, config) iterable = getattr( b, mainattr).values() if mainattr == 'cells' else b.me keyattr = 'position' if mainattr == 'cells' else 'id' for s in iterable: if attr == 'position' and s.halite > 0: continue if mainattr == 'cells' and s.halite == 0 or s.position not in qps: continue key = getattr(s, keyattr) if key not in precord: precord[key] = {} precord[key][step] = getattr(s, attr) else: precord[key][step] = getattr(s, attr) return record
def action_act(args): global cached_agent if len(args.agents) != 1: return {"error": "One agent must be provided."} raw = args.agents[0] # Process the configuration. # (additional environment specificproperties come along without being checked). err, config = utils.structify( utils.process_schema(utils.schemas["configuration"], args.configuration)) if err: return {"error": err} timeout = config.actTimeout if cached_agent == None or cached_agent.id != raw: if cached_agent != None: cached_agent.destroy() cached_agent = Agent(raw, config, raw) timeout = config.agentTimeout state = { "observation": utils.get(args.state, dict, {}, ["observation"]), "reward": args.get("reward", None), "info": utils.get(args.state, dict, {}, ["info"]) } action = cached_agent.act(state, timeout) if isinstance(action, errors.DeadlineExceeded): action = "DeadlineExceeded" elif isinstance(action, BaseException): action = "BaseException" return {"action": action}
def replay_match(path, step=0): """Replay game to a specific step - necessary for recreating stateful values.""" with open(path,encoding='ascii') as f: match = json.load(f) env = make("halite", configuration=match['configuration'], steps=match['steps']) myid = [pid for pid, name in enumerate(match['info']['TeamNames']) if name == "Ready Salted"][0] config = env.configuration # env already done - can write out full replay t = env.render(mode='html', return_obj=True, width=800, height=800, header=False, controls=True) write_html(t, 'replay.html') # If agent carries state across turns, need to run through all steps, or can directly index into a step otherwise # check that we are correct player # print('My Id: ', board.current_player_id, board.current_player) print(f'Running for:\n\t{path}\n\t{agent.__module__}\n\tID = {myid}\n') actTime = 0 for step in range(400): state = match['steps'][step][0] # list of length 1 for each step obs = state['observation'] # these are observations at this step obs['player'] = myid # change the player to the one we want to inspect obs = structify(obs) # turn the dict's into structures with attributes icon = '\|/-'[(obs.step+1) % 4] t0 = time.time() ret = agent(obs, config) actTime = time.time() - t0 print(f'{icon} step+1: {obs.step +1} StepTime:{round(actTime,2)}')#, end="\r", flush=True)
def test_can_step_through_agents(): before_each() while not env.done: action1 = env.agents.random(env.state[0].observation) action2 = env.agents.reaction( utils.structify({"board": env.state[0].observation.board, "mark": 2})) env.step([action1, action2]) assert env.state[0].reward + env.state[1].reward == 0
def test_football_env_run_30_steps(self): env = KaggleFootballMultiAgentEnv() # use the built-in agents in the kaggle environment run_right_agent = env.kaggle_env.agents["run_right"] do_nothing_agent = env.kaggle_env.agents["do_nothing"] obs = env.reset() self.assertEqual(list(obs.keys()), ["agent0", "agent1"]) done = {"__all__": False} num_steps_completed = 0 while not done["__all__"] and num_steps_completed <= 30: action0 = run_right_agent(structify(obs["agent0"]))[0] action1 = do_nothing_agent(structify(obs["agent1"]))[0] action_dict = {"agent0": action0, "agent1": action1} obs, _, done, _ = env.step(action_dict) num_steps_completed += 1
def action_handler(args): args = utils.structify({ "action": utils.get(args, str, "list", ["action"]), "agents": utils.get(args, list, [], ["agents"]), "configuration": utils.get(args, dict, {}, ["configuration"]), "environment": args.get("environment", None), "episodes": utils.get(args, int, 1, ["episodes"]), "steps": utils.get(args, list, [], ["steps"]), "render": utils.get(args, dict, {"mode": "json"}, ["render"]), "debug": utils.get(args, bool, False, ["debug"]) }) for index, agent in enumerate(args.agents): agent = utils.read_file(agent, agent) args.agents[index] = utils.get_last_callable(agent, agent) if args.action == "list": return action_list(args) if args.environment == None: return {"error": "Environment required."} try: if args.action == "http-server": return {"error": "Already running a http server."} elif args.action == "evaluate": return action_evaluate(args) elif args.action == "step": return action_step(args) elif args.action == "run": return action_run(args) elif args.action == "load": return action_load(args) else: return {"error": "Unknown Action"} except Exception as e: return {"error": str(e), "trace": traceback.format_exc()}
def interpreter(state, env): obs = state[0].observation config = env.configuration # Initialize the board (place cell halite and starting ships). if env.done: return populate_board(state, env) # Interpreter invoked here actions = [agent.action for agent in state] board = Board(obs, config, actions) board = board.next() state[0].observation = obs = utils.structify(board.observation) # Remove players with invalid status or insufficient potential. for index, agent in enumerate(state): player_halite, shipyards, ships = obs.players[index] if agent.status == "ACTIVE" and len(ships) == 0 and ( len(shipyards) == 0 or player_halite < config.spawnCost): # Agent can no longer gather any halite agent.status = "DONE" agent.reward = board.step - board.configuration.episode_steps - 1 if agent.status != "ACTIVE" and agent.status != "DONE": obs.players[index] = [0, {}, {}] # Check if done (< 2 players and num_agents > 1) if len(state) > 1 and sum( 1 for agent in state if agent.status == "ACTIVE") < 2: for agent in state: if agent.status == "ACTIVE": agent.status = "DONE" # Update Rewards. for index, agent in enumerate(state): if agent.status == "ACTIVE": agent.reward = obs.players[index][0] elif agent.status != "DONE": agent.reward = 0 return state