def main(_):
left_players = FLAGS.left_players.split(',') if FLAGS.left_players else ''
right_players = FLAGS.right_players.split(
',') if FLAGS.right_players else ''
assert not (
'agent' in left_players or 'agent' in right_players
), 'Player type \'agent\' can not be used with play_game. Use tfhub player.'
cfg = config.Config({
'action_set': FLAGS.action_set,
'right_players': right_players,
'dump_full_episodes': True,
'left_players': left_players,
'real_time': FLAGS.real_time,
'render': True
})
if FLAGS.level:
cfg['level'] = FLAGS.level
env = football_env.FootballEnv(cfg)
env.reset()
try:
while True:
_, _, done, _ = env.step(None)
if done:
env.reset()
except KeyboardInterrupt:
env.write_dump('shutdown')
exit(1)
def main(_):
with open(FLAGS.trace_file, 'rb') as f:
replay = six.moves.cPickle.load(f)
trace = modify_trace(replay)
fd, temp_path = tempfile.mkstemp(suffix='.dump')
with tf.gfile.Open(temp_path, 'wb') as f:
six.moves.cPickle.dump(trace, f)
assert replay[0]['debug']['frame_cnt'] == 1, (
'Trace does not start from the beginning of the episode, can not replay')
cfg = config.Config(replay[0]['debug']['config'])
player_type = 'replay={}'.format(temp_path)
cfg['home_players'] = [player_type] * len(cfg['home_players'])
cfg['away_players'] = [player_type] * len(cfg['away_players'])
cfg.update({
'physics_steps_per_frame': int(100 / FLAGS.fps),
'real_time': False,
'render': True,
'tracesdir': '/tmp/dumps',
'write_video': True
})
env = football_env.FootballEnv(cfg)
env.reset(cfg)
done = False
try:
while not done:
_, _, done, _ = env.step(None)
except KeyboardInterrupt:
env.write_dump('shutdown')
exit(1)
os.close(fd)
def test_corner(self, episode, factor, reverse):
cfg = config.Config({
'level': 'tests.corner_test',
'players': ['agent:left_players=1,right_players=1'],
'episode_number': episode,
'reverse_team_processing': reverse,
})
env = football_env.FootballEnv(cfg)
o = env.reset()
done = False
while not done:
o, _, done, _ = env.step([
football_action_set.action_left,
football_action_set.action_left
])
self.assertAlmostEqual(o[0]['ball'][0], -0.95 * factor, delta=0.1)
self.assertAlmostEqual(o[0]['ball'][1], 0.4 * factor, delta=0.1)
self.assertAlmostEqual(o[0]['right_team'][0][0], 1, delta=0.1)
self.assertAlmostEqual(o[0]['right_team'][1][0],
-0.95 * factor,
delta=0.1)
self.assertAlmostEqual(o[0]['left_team'][0][0], -0.95, delta=0.1)
self.assertAlmostEqual(o[0]['left_team'][1][0],
-0.9 * factor,
delta=0.2)
env.close()
def testActionFlipping(self):
cfg = config.Config()
for action in football_action_set.full_action_set:
# Flipping twice should give the same action.
action_id = observation_rotation.flip_single_action(
observation_rotation.flip_single_action(action, cfg), cfg)
self.assertEqual(action, action_id)
def main(_):
players = FLAGS.players.split(';') if FLAGS.players else ''
assert not (any(['agent' in player for player in players])
), ('Player type \'agent\' can not be used with play_game.')
cfg = config.Config({
'action_set': FLAGS.action_set,
'dump_full_episodes': True,
'players': players,
'real_time': FLAGS.real_time,
})
if FLAGS.level:
cfg['level'] = FLAGS.level
env = football_env.FootballEnv(cfg)
if FLAGS.render:
env.render()
env.reset()
try:
while True:
_, _, done, _ = env.step([])
if done:
env.reset()
except KeyboardInterrupt:
logging.warning('Game stopped, writing dump...')
env.write_dump('shutdown')
exit(1)
def test_setstate(self, seed):
"""Checks setState functionality."""
cfg = config.Config({
'level': 'tests.symmetric',
'game_engine_random_seed': seed
})
env1 = football_env.FootballEnv(cfg)
env2 = football_env.FootballEnv(cfg)
initial_obs = env1.reset()
env2.reset()
initial_state = env1.get_state()
random.seed(seed)
actions = len(football_action_set.get_action_set(cfg))
first_action = random.randint(0, actions - 1)
first_obs, _, _, _ = env1.step(first_action)
_, _, _, _ = env2.step(first_action)
step = 0
limit = 10 if fast_run else 3000
while step < limit:
step += 1
action = random.randint(0, actions - 1)
if step % 10 == 0:
env2.set_state(initial_state)
self.compare_observations(initial_obs, env2.observation())
env2.step(first_action)
self.compare_observations(first_obs, env2.observation())
env2.set_state(env1.get_state())
self.compare_observations(env1.observation(), env2.observation())
_, _, done1, _ = env1.step(action)
_, _, done2, _ = env2.step(action)
self.assertEqual(done1, done2)
if done1:
break
env1.close()
env2.close()
def replay(self, dump, fps=10, config_update={}, directory=None):
with open(dump, 'rb') as f:
replay = six.moves.cPickle.load(f)
trace = self.__modify_trace(replay, fps)
fd, temp_path = tempfile.mkstemp(suffix='.dump')
with open(temp_path, 'wb') as f:
six.moves.cPickle.dump(trace, f)
assert replay[0]['debug']['frame_cnt'] == 1, (
'Trace does not start from the beginning of the episode, can not replay'
)
cfg = config.Config(replay[0]['debug']['config'])
cfg['players'] = self.__build_players(temp_path, cfg['players'])
config_update['physics_steps_per_frame'] = int(100 / fps)
config_update['real_time'] = False
if 'render' not in config_update:
config_update['render'] = True
if directory:
config_update['tracesdir'] = directory
config_update['write_video'] = True
cfg.update(config_update)
env = football_env.FootballEnv(cfg)
env.reset()
done = False
try:
while not done:
_, _, done, _ = env.step(None)
except KeyboardInterrupt:
env.write_dump('shutdown')
exit(1)
os.close(fd)
def main(_):
cfg = config.Config({
'action_set':
FLAGS.action_set,
'away_players':
FLAGS.away_players.split(',') if FLAGS.away_players else '',
'dump_full_episodes':
True,
'home_players':
FLAGS.home_players.split(',') if FLAGS.home_players else '',
'real_time':
FLAGS.real_time,
'render':
True
})
if FLAGS.level:
cfg['level'] = FLAGS.level
env = football_env.FootballEnv(cfg)
env.reset(cfg)
try:
while True:
_, _, done, _ = env.step(None)
if done:
env.reset(cfg)
except KeyboardInterrupt:
env.write_dump('shutdown')
exit(1)
def generate_replay(self):
"""Generates replay of an episode."""
cfg = config.Config()
left_players = 2
cfg.update({
'action_set':
'full',
'level':
'tests.corner_test',
'dump_full_episodes':
True,
'players': [
'agent:left_players={}'.format(left_players),
'bot:right_players=1', 'lazy:right_players=1'
],
'tracesdir':
test_tmpdir
})
env = football_env.FootballEnv(cfg)
env.reset()
actions_cnt = len(football_action_set.get_action_set(cfg))
done = False
step = 0
while not done:
step += 1
actions = [(step + x) % actions_cnt for x in range(left_players)]
_, _, done, _ = env.step(actions)
env.close()
def test_render_state_equals_norender(self, seed):
"""Checks that rendering game state is the same as non-rendering."""
if 'UNITTEST_IN_DOCKER' in os.environ:
# Forge doesn't support rendering.
return
processes = []
cfg1 = config.Config({
'level':
'tests.symmetric',
'game_engine_random_seed':
seed,
'players': ['agent:left_players=1,right_players=1'],
'reverse_team_processing':
False,
})
cfg2 = config.Config({
'level':
'tests.symmetric',
'game_engine_random_seed':
seed,
'players': ['agent:left_players=1,right_players=1'],
'reverse_team_processing':
False,
})
random.seed(seed)
action_cnt = len(football_action_set.get_action_set(cfg1))
actions = [random.randint(0, action_cnt - 1) for _ in range(50)]
queue1 = Queue()
thread1 = threading.Thread(target=run_scenario,
args=(cfg1, seed, queue1, actions, False,
False))
thread1.start()
queue2 = Queue()
thread2 = threading.Thread(target=run_scenario,
args=(cfg2, seed, queue2, actions, True,
False))
thread2.start()
while True:
o1 = queue1.get()
o2 = queue2.get()
if not o1 or not o2:
self.assertEqual(o1, o2)
break
self.compare_observations(o1, o2)
thread1.join()
thread2.join()
def test_symmetry(self, seed):
"""Checks game symmetry."""
processes = []
cfg1 = config.Config({
'level':
'tests.symmetric',
'game_engine_random_seed':
seed,
'players': ['agent:left_players=1,right_players=1'],
'reverse_team_processing':
False,
})
cfg2 = config.Config({
'level':
'tests.symmetric',
'game_engine_random_seed':
seed,
'players': ['agent:left_players=1,right_players=1'],
'reverse_team_processing':
True,
})
random.seed(seed)
action_cnt = len(football_action_set.get_action_set(cfg1))
actions = [
random.randint(0, action_cnt - 1)
for _ in range(10 if fast_run else 3000)
]
queue1 = Queue()
thread1 = threading.Thread(target=run_scenario,
args=(cfg1, queue1, actions))
thread1.start()
queue2 = Queue()
thread2 = threading.Thread(target=run_scenario,
args=(cfg2, queue2, actions))
thread2.start()
while True:
o1 = queue1.get()
o2 = queue2.get()
if not o1 or not o2:
self.assertEqual(o1, o2)
break
self.compare_observations(o1[:1], o2[1:])
self.compare_observations(o2[:1], o1[1:])
thread1.join()
thread2.join()
def test_action_builtin_ai(self):
"""Verify action_builtin_ai behaves the same as AI controlled player."""
seed = 123
cfg1 = config.Config({
'game_engine_random_seed': seed,
'players': ['agent:left_players=1'],
})
cfg2 = config.Config({
'game_engine_random_seed': seed,
'players': ['agent:left_players=11'],
})
random.seed(seed)
actions1 = Queue()
actions2 = Queue()
queue1 = Queue()
thread1 = threading.Thread(
target=run_scenario, args=(cfg1, queue1, actions1, False, False))
thread1.start()
queue2 = Queue()
thread2 = threading.Thread(
target=run_scenario, args=(cfg2, queue2, actions2, False, False))
thread2.start()
while True:
o1 = queue1.get()
o2 = queue2.get()
if not o1 or not o2:
self.assertEqual(o1, o2)
break
# Verify that players don't switch when controlling everyone.
ids = [player['active'] for player in o2]
self.assertEqual(ids, [6, 5, 7, 8, 10, 0, 9, 2, 3, 1, 4])
o2_single = wrappers.MultiAgentToSingleAgent.get_observation(o2)
self.assertEqual(o1[0]['active'], o1[0]['designated'])
self.compare_observations(o1, o2_single)
o2_single[0]['active'] = o2_single[0]['designated']
action = football_action_set.action_builtin_ai
actions1.put([action])
action = wrappers.MultiAgentToSingleAgent.get_action([action], o2)
actions2.put(action)
thread1.join()
thread2.join()
def test_different_action_formats(self): """Verify different action formats are accepted.""" cfg = config.Config() env = football_env.FootballEnv(cfg) env.reset() env.step(football_action_set.action_right) env.step([football_action_set.action_right]) env.step(np.array([football_action_set.action_right])) env.step(np.array(football_action_set.action_right)) env.close()
def test_player_order_invariant(self):
"""Checks that environment behaves the same regardless of players order."""
players = ['agent:right_players=1', 'lazy:left_players=11']
cfg = config.Config({
'level': 'tests.11_vs_11_hard_deterministic',
'players': players
})
env = football_env.FootballEnv(cfg)
actions = len(football_action_set.get_action_set(cfg))
hash_value1 = compute_hash(env, actions)
players = [players[1], players[0]]
cfg = config.Config({
'level': 'tests.11_vs_11_hard_deterministic',
'players': players
})
env = football_env.FootballEnv(cfg)
hash_value2 = compute_hash(env, actions)
self.assertEqual(hash_value1, hash_value2)
env.close()
def dump_to_video(self, dump_file):
dump = self.load_dump(dump_file)
cfg = config.Config(dump[0]['debug']['config'])
cfg['dump_full_episodes'] = True
cfg['write_video'] = True
cfg['display_game_stats'] = True
processor = observation_processor.ObservationProcessor(cfg)
processor.write_dump('episode_done')
for frame in dump:
processor.update(frame)
def main(_):
cfg = config.Config()
cfg['dump_full_episodes'] = True
cfg['write_video'] = True
cfg['display_game_stats'] = True
with open(FLAGS.file, 'rb') as f:
dump = six.moves.cPickle.load(f)
processor = observation_processor.ObservationProcessor(cfg)
for frame in dump:
processor.update(frame)
processor.write_dump('episode_done')
def dump_to_video(self, dump_file):
with open(dump_file, 'rb') as f:
dump = six.moves.cPickle.load(f)
cfg = config.Config(dump[0]['debug']['config'])
cfg['dump_full_episodes'] = True
cfg['write_video'] = True
cfg['display_game_stats'] = True
processor = observation_processor.ObservationProcessor(cfg)
for frame in dump:
processor.update(frame)
processor.write_dump('episode_done')
def test_restore_after_done(self):
cfg = config.Config({
'level': 'academy_empty_goal_close',
})
env = football_env.FootballEnv(cfg)
env.reset()
state = env.get_state()
# Go right until reaching the goal.
done = False
while not done:
_, _, done, _ = env.step(5)
env.set_state(state)
env.step(0) # Test if can take step
def test_restore_after_reset(self):
cfg = config.Config({
'level': '11_vs_11_competition',
})
env = football_env.FootballEnv(cfg)
obs = env.reset()
state = env.get_state()
env.reset()
env.set_state(state)
obs_ = env.observation()
state_ = env.get_state()
env.step(0) # Test if can take step
self.compare_observations(obs, obs_)
self.assertEqual(state, state_)
def check_determinism(self, extensive=False):
"""Check that environment is deterministic."""
if 'UNITTEST_IN_DOCKER' in os.environ:
return
cfg = config.Config({'level': 'tests.11_vs_11_hard_deterministic'})
env = football_env.FootballEnv(cfg)
actions = len(football_action_set.get_action_set(cfg))
for episode in range(1 if extensive else 2):
hash_value = compute_hash(env, actions, extensive)
if extensive:
self.assertEqual(hash_value, 4203104251)
elif episode % 2 == 0:
self.assertEqual(hash_value, 716323440)
else:
self.assertEqual(hash_value, 1663893701)
env.close()
def test__memory_usage(self):
"""Make sure memory usage is low when not recording videos."""
# This test has to go first, so that memory usage is not affected.
if 'UNITTEST_IN_DOCKER' in os.environ:
# Forge doesn't support rendering.
return
cfg = config.Config({'write_video': False})
env = football_env.FootballEnv(cfg)
env.render()
env.reset()
initial_memory = self.memory_usage()
for _ in range(100):
_, _, _, _ = env.step(football_action_set.action_right)
memory_usage = self.memory_usage() - initial_memory
env.close()
self.assertGreaterEqual(10000000, memory_usage)
def test_second_half(self):
"""Test second half feature."""
cfg = config.Config()
cfg['level'] = 'tests.second_half'
env = football_env.FootballEnv(cfg)
for _ in range(5):
o, _, done, _ = env.step(football_action_set.action_idle)
self.assertFalse(done)
self.assertAlmostEqual(o[0]['left_team'][o[0]['active']][0], 0, delta=0.1)
for _ in range(6):
self.assertFalse(done)
o, _, done, _ = env.step(football_action_set.action_idle)
self.assertAlmostEqual(
o[0]['left_team'][o[0]['active']][0], -0.5, delta=0.1)
self.assertTrue(done)
env.close()
def test_goal(self, episode, reverse):
cfg = config.Config({
'level': 'tests.goal_test',
'players': ['agent:left_players=1,right_players=1'],
'episode_number': episode,
'reverse_team_processing': reverse,
})
env = football_env.FootballEnv(cfg)
o = env.reset()
done = False
while not done:
o, _, done, _ = env.step(
[football_action_set.action_right, football_action_set.action_right])
self.assertAlmostEqual(o[0]['ball'][0], 0.0, delta=0.1)
self.assertEqual(o[0]['score'][episode], 1)
self.assertEqual(o[0]['score'][1 - episode], 0)
env.close()
def test_penalty(self):
cfg = config.Config({
'level': 'tests.penalty',
'players': ['agent:left_players=1'],
})
env = football_env.FootballEnv(cfg)
o = env.reset()
done = False
while not done:
o, _, done, _ = env.step([football_action_set.action_sliding])
self.assertAlmostEqual(o[0]['ball'][0], -0.809, delta=0.01)
self.assertAlmostEqual(o[0]['ball'][1], 0.0, delta=0.01)
self.assertAlmostEqual(o[0]['right_team'][0][0], 1, delta=0.1)
self.assertAlmostEqual(o[0]['right_team'][1][0], -0.75, delta=0.1)
self.assertAlmostEqual(o[0]['left_team'][0][0], -0.95, delta=0.1)
self.assertAlmostEqual(o[0]['left_team'][1][0], -0.70, delta=0.1)
env.close()
def test___render(self):
"""Make sure rendering is not broken."""
if 'UNITTEST_IN_DOCKER' in os.environ:
# Rendering is not supported.
return
cfg = config.Config({
'level': 'tests.11_vs_11_hard_deterministic',
})
env = football_env.FootballEnv(cfg)
env.render()
o = env.reset()
hash = observation_hash(o)
for _ in range(10):
o, _, _, _ = env.step(football_action_set.action_right)
hash = observation_hash(o, hash)
self.assertEqual(hash, 2763980076)
env.close()
def testObservationFlipping(self):
cfg = config.Config()
num_players = 11
observation = {}
observation['left_team'] = np.random.rand(num_players * 2) - 0.5
observation['left_team_roles'] = np.random.rand(num_players)
observation['left_team_direction'] = np.random.rand(
num_players * 2) - 0.5
observation['left_team_tired_factor'] = np.random.rand(num_players)
observation['left_team_yellow_card'] = np.random.rand(num_players)
observation['left_team_active'] = [3]
observation['left_team_designated_player'] = 3
observation['right_team'] = np.random.rand(num_players * 2) - 0.5
observation['right_team_roles'] = np.random.rand(num_players)
observation['right_team_direction'] = np.random.rand(
num_players * 2) - 0.5
observation['right_team_tired_factor'] = np.random.rand(num_players)
observation['right_team_yellow_card'] = np.random.rand(num_players)
observation['right_team_active'] = [0]
observation['right_team_designated_player'] = 0
observation['ball'] = np.array([1, -1, 0])
observation['ball_direction'] = np.random.rand(3) - 0.5
observation['ball_rotation'] = np.random.rand(3) - 0.5
observation['ball_owned_team'] = 0
observation['ball_owned_player'] = 7
observation['left_agent_controlled_player'] = [4]
observation['right_agent_controlled_player'] = [6]
observation['game_mode'] = 123
observation['left_agent_sticky_actions'] = [[
np.random.rand(2) for _ in range(10)
]]
observation['right_agent_sticky_actions'] = [[
np.random.rand(2) for _ in range(10)
]]
observation['score'] = [3, 5]
observation['steps_left'] = 45
# Flipping twice the observation is the identity.
flipped_observation = observation_rotation.flip_observation(
observation, cfg)
original_observation = observation_rotation.flip_observation(
flipped_observation, cfg)
self.assertEqual(str(tuple(sorted(original_observation.items()))),
str(tuple(sorted(observation.items()))))
def test_offside(self, episode, team2, reverse):
cfg = config.Config({
'level': 'tests.offside_test',
'players': ['agent:{}_players=1'.format(team2)],
'episode_number': episode,
'reverse_team_processing': reverse,
})
env = football_env.FootballEnv(cfg)
env.reset()
o, _, done, _ = env.step(football_action_set.action_long_pass)
done = False
while not done and o[0]['right_team'][1][0] == 0:
o, _, done, _ = env.step(football_action_set.action_idle)
self.assertAlmostEqual(o[0]['ball'][0], 0.6, delta=0.4)
self.assertAlmostEqual(o[0]['right_team'][0][0], 0.6, delta=0.4)
self.assertAlmostEqual(o[0]['right_team'][1][0], 0.6, delta=0.4)
self.assertAlmostEqual(o[0]['left_team'][0][0], -0.6, delta=0.4)
self.assertAlmostEqual(o[0]['left_team'][1][0], -0.6, delta=0.4)
env.close()
def create_multiagent_env(iprocess):
left_player = 'ppo2_cnn:left_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2'
right_player = 'agent:right_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2'
players = [left_player, right_player]
write_full_episode_dumps = False and (iprocess == 0)
write_goal_dumps = False and (iprocess == 0)
config_values = {
'dump_full_episodes': write_full_episode_dumps,
'dump_scores': write_goal_dumps,
'players': players,
'level': '11_vs_11_easy_stochastic',
'tracesdir': '', # logdir
'write_video': False
}
cfg = config.Config(config_values)
env = football_env.FootballEnv(cfg)
render = False and (iprocess == 0)
if render:
env.render()
dump_frequency = 10 if render and iprocess == 0 else 0
env = wrappers.PeriodicDumpWriter(env, dump_frequency)
rewards = 'scoring,checkpoints' # what to base rewards on
representation = 'extracted' # ['simple115v2'] what observations model gets
channel_dimensions = (observation_preprocessing.SMM_WIDTH,
observation_preprocessing.SMM_HEIGHT)
apply_single_agent_wrappers = True
stacked = True # whether to get last 4 observations stacked or just last 1
env = _apply_output_wrappers(env, rewards, representation,
channel_dimensions,
apply_single_agent_wrappers, stacked)
env = monitor.Monitor(
env,
logger.get_dir() and os.path.join(logger.get_dir(), str(iprocess)))
return env
def main(_):
left_player = 'ppo2_cnn:left_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2'
right_player = 'ppo2_cnn:right_players=1,policy=gfootball_impala_cnn,checkpoint=/Users/stephen/Documents/football/checkpoints/11_vs_11_easy_stochastic_v2'
players = [left_player, right_player]
config_values = {'dump_full_episodes': False,
'dump_scores': False,
'players': players,
'level': '11_vs_11_easy_stochastic',
'tracesdir': '/Users/stephen/Documents/football/logs', # logdir
'write_video': False}
cfg = config.Config(config_values)
env = football_env.FootballEnv(cfg)
render = False
if render:
env.render()
env.reset()
dump_frequency = 3
env = wrappers.PeriodicDumpWriter(env, dump_frequency)
n_timesteps = int(2 * 3e3 + 1) # 3k per episode
right_agent_ep_scores = []
ep_right_scores = 0.0
for _ in range(n_timesteps):
_, reward, done, _ = env.step([])
ep_right_scores -= reward
if done:
right_agent_ep_scores.append(ep_right_scores)
ep_right_scores = 0.0
env.reset()
mean_score = sum(right_agent_ep_scores) / len(right_agent_ep_scores)
print(f'\n***\nRight agent episode scores: {right_agent_ep_scores}\n' +
f'Right agent episode mean score: {mean_score}\n***\n')
def test_dynamic_render(self):
"""Verifies dynamic render support."""
if 'UNITTEST_IN_DOCKER' in os.environ:
# Rendering is not supported.
return
cfg = config.Config({
'level': 'tests.11_vs_11_hard_deterministic',
})
env = football_env.FootballEnv(cfg)
o = env.reset()
for _ in range(10):
o, _, _, _ = env.step(football_action_set.action_right)
self.assertNotIn('frame', o[0])
env.render()
self.assertIn('frame', env.observation()[0])
self.compare_observations(o, env.observation())
o, _, _, _ = env.step(football_action_set.action_right)
self.assertIn('frame', env.observation()[0])
env.disable_render()
self.compare_observations(o, env.observation())
env.close()
