def reset(self, config, trace):
global _engine
global _engine_in_use
"""Reset environment for a new episode using a given config."""
self._waiting_for_game_count = 0
self._steps_time = 0
self._step = 0
self._config = config
self._trace = trace
self._observation = None
self._info = None
self._done = False
self._config.NewScenario()
self._scenario_cfg = self._config.ScenarioConfig()
if not self._env:
assert not _engine_in_use, ('Environment does not support multiple '
'instances of the game in the same process.')
_engine_in_use = True
if not _engine:
_engine = libgame.GameEnv()
_engine.start_game(self._config.GameConfig())
self._env = _engine
self._home_controllers = []
self._away_controllers = []
for _ in range(self._scenario_cfg.home_agents):
controller = football_action_set.StickyWrapper(config, self)
self._home_controllers.append(controller)
for _ in range(self._scenario_cfg.away_agents):
controller = football_action_set.StickyWrapper(config, self)
self._away_controllers.append(controller)
self._env.reset(self._config.ScenarioConfig())
while not self._retrieve_observation():
self._env.step()
return True
def render(self, mode):
global _unused_rendering_engine
if self._env.state == GameState.game_created:
self._rendering_in_use()
return False
if not self._env.game_config.render:
if not self._use_rendering_engine:
if self._env.state != GameState.game_created:
state = self.get_state({})
self._release_engine()
if _unused_rendering_engine:
self._env = _unused_rendering_engine
_unused_rendering_engine = None
else:
self._env = libgame.GameEnv()
self._rendering_in_use()
self._reset(animations=False, inc=0)
self.set_state(state)
# We call render twice, as the first call has bad camera position.
self._env.render(False)
else:
self._env.game_config.render = True
self._env.render(True)
self._retrieve_observation()
if mode == 'rgb_array':
frame = self._observation['frame']
b, g, r = cv2.split(frame)
return cv2.merge((r, g, b))
elif mode == 'human':
return True
return False
def _get_new_env(self):
env = libgame.GameEnv()
env.game_config.physics_steps_per_frame = self._config[
'physics_steps_per_frame']
env.game_config.render_resolution_x = self._config['render_resolution_x']
env.game_config.render_resolution_y = self._config['render_resolution_y']
return env
def __init__(self, config):
global _unused_engines
self._config = config
if _unused_engines:
self._env = _unused_engines.pop()
else:
self._env = libgame.GameEnv()
self._env.game_config.physics_steps_per_frame = config[
'physics_steps_per_frame']
self._sticky_actions = football_action_set.get_sticky_actions(config)
self._use_rendering_engine = False
def __init__(self, config):
global _unused_engines
self._config = config
self._sticky_actions = football_action_set.get_sticky_actions(config)
self._use_rendering_engine = False
if _unused_engines:
self._env = _unused_engines.pop()
else:
self._env = libgame.GameEnv()
self._env.game_config.physics_steps_per_frame = config['physics_steps_per_frame']
# Reset is needed here to make sure render() API call before reset() API
# call works fine (get/setState makes sure env. config is the same).
self.reset(inc=0)
def reset(self, trace):
global _engine
global _engine_in_use
global _rendering_supported
"""Reset environment for a new episode using a given config."""
self._waiting_for_game_count = 0
self._steps_time = 0
self._step = 0
self._trace = trace
self._observation = None
self._info = None
self._done = False
self._config.NewScenario()
self._scenario_cfg = self._config.ScenarioConfig()
if not self._env:
assert not _engine_in_use, (
'Environment does not support multiple '
'instances of the game in the same process.')
if not _engine:
_engine = libgame.GameEnv()
_engine.start_game(self._config.GameConfig())
_rendering_supported = self._config['render']
else:
assert _rendering_supported or not self._config['render'], (
'Enabling '
'rendering when initially it was disabled is not supported.'
)
_engine_in_use = True
self._env = _engine
self._left_controllers = []
self._right_controllers = []
for _ in range(self._scenario_cfg.left_agents):
controller = football_action_set.StickyWrapper(self._config, self)
self._left_controllers.append(controller)
for _ in range(self._scenario_cfg.right_agents):
controller = football_action_set.StickyWrapper(self._config, self)
self._right_controllers.append(controller)
self._env.reset(self._config.ScenarioConfig())
while not self._retrieve_observation():
self._env.step()
return True
def reset(self, trace):
"""Reset environment for a new episode using a given config."""
global _unused_engines
global _unused_rendering_engine
self._waiting_for_game_count = 0
self._steps_time = 0
self._step = 0
self._trace = trace
self._observation = None
self._info = None
self._done = False
self._config.NewScenario()
self._scenario_cfg = self._config.ScenarioConfig()
if not self._env:
if self._config['render']:
if _unused_rendering_engine:
self._env = _unused_rendering_engine
_unused_rendering_engine = None
self.rendering_in_use()
else:
if _unused_engines:
self._env = _unused_engines.pop()
if not self._env:
if self._config['render']:
self.rendering_in_use()
self._env = libgame.GameEnv()
self._env.start_game(self._config.GameConfig())
self._left_controllers = []
self._right_controllers = []
for _ in range(self._scenario_cfg.left_agents):
controller = football_action_set.StickyWrapper(self._config, self)
self._left_controllers.append(controller)
for _ in range(self._scenario_cfg.right_agents):
controller = football_action_set.StickyWrapper(self._config, self)
self._right_controllers.append(controller)
self._env.reset(self._config.ScenarioConfig())
while not self._retrieve_observation():
self._env.step()
return True
