def __init__(
self,
render=False,
config_path='/home/gberseth/playground/BayesianSurpriseCode/surprise/envs/vizdoom/scenarios/take_cover.cfg',
god=False,
respawn=True):
# Start game
self.game = vzd.DoomGame()
# Set sleep time (for visualization)
self.sleep_time = 0
self.game.set_window_visible(render)
self.sleep_time = .02 * int(render)
# Game Configs
self.game.load_config(config_path)
self.game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
self.game.set_render_screen_flashes(True) # Effect upon taking damage
self.episode_length = 1000
self.skiprate = 2
self.game.set_episode_timeout(self.episode_length * self.skiprate)
# Initialize the game
self.game.init()
# Actions are left or right
self.actions = [[True, False], [False, True]]
# Env Variables
self.done = False
self.time = 1
self.downsample_factor = .02
self.obs_hist = [self.get_random_state(res=(48, 64)) for _ in range(4)]
self.god = god
self.respawn = respawn
self.deaths = 0
self.fireball = 0
# Spaces
self.action_space = spaces.Discrete(2)
self.observation_space = spaces.Box(0,
self.episode_length,
shape=(4, 48, 64))
# RND stuff
self.buffer = SimpleBuffer(device=device)
self.target_net = VizdoomFeaturizer(64).to(device)
self.target_net.eval()
self.pred_net = VizdoomFeaturizer(64).to(device)
self.optimizer = optim.Adam(self.pred_net.parameters(), lr=1e-4)
self.step_freq = 8
self.loss = torch.zeros(1)
self.reset()
def initialize_vizdoom(args):
print("[1.] Initializing ViZDoom...")
game = vizdoom.DoomGame()
game.load_config(args.config_file)
game.set_window_visible(args.enable_training_view)
game.set_mode(vizdoom.Mode.PLAYER)
game.set_screen_format(vizdoom.ScreenFormat.GRAY8)
game.set_screen_resolution(vizdoom.ScreenResolution.RES_640X480)
game.init()
print("[.1] ... ViZDoom initialized.")
return game
def __init__(
self,
render=False,
config_path='./surprise/envs/vizdoom/scenarios/take_cover.cfg',
god=True,
num_actions=2,
**kwargs):
#def __init__(self, render=False, config_path='/home/dangengdg/minimalEntropy/tree_search/vizdoom/scenarios/take_cover.cfg', vae=False, god=True, respawn=True):
# Start game
self.game = vzd.DoomGame()
# Set sleep time (for visualization)
self.sleep_time = 0
self.__render = render
if (self.__render == True):
self.game.set_window_visible(self.__render)
self.sleep_time = .02 * int(self.__render)
else:
self.game.set_window_visible(False)
# Game Configs
self.game.load_config(config_path)
self.game.set_screen_resolution(vzd.ScreenResolution.RES_160X120)
# self.game.set_screen_format(vzd.ScreenFormat.BGR24)
# self.game.set_screen_format(vzd.ScreenFormat.DOOM_256_COLORS8)
self.game.set_render_screen_flashes(True) # Effect upon taking damage
self.episode_length = 1000
self.skiprate = 2
self.game.set_episode_timeout(self.episode_length * self.skiprate)
# Initialize the game
self.game.init()
# Actions are left or right
# self.actions = [[True, False], [False, True]]
self.actions = [
list(x) for x in np.eye(
self.game.get_available_buttons_size()).astype(bool)
]
# Env Variables
self.done = False
self.time = 1
self.downsample_factor = .02
self.god = god
self.fireball = 0
self.in_fireball = 0
self.health = 100
# Buffer
self.action_space = spaces.Discrete(len(self.actions))
self.observation_space = spaces.Box(-1, 1, shape=(120, 160, 3))
self.reset()
def initialize_vizdoom(self, config_file_path):
#print("Initializing doom...")
game = vzd.DoomGame()
game.load_config(config_file_path)
game.set_window_visible(False)
game.set_mode(vzd.Mode.PLAYER)
game.set_screen_format(vzd.ScreenFormat.GRAY8)
game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
game.init()
#print("Doom initialized.")
return game
def __init__(self, cfg_config_path, window_visible=False):
super(AtariDoom, self).__init__()
game = vzd.DoomGame()
game.load_config(cfg_config_path)
game.set_window_visible(window_visible)
game.init()
self.game = game
self.timestep = 0
self.timeout = game.get_episode_timeout()
# print(self.timeout)
self.cfg_config_path = cfg_config_path
def __init__(self, args):
self.modalities = args['modalities']
self.outputs = args['outputs']
self.config = args['config']
self.resolution = (args['width'], args['height'])
self.frame_skip = args['frame_skip']
self.color_mode = args['color_mode']
#self.use_shaping_reward = args['use_shaping_reward']
self.switch_maps = args['switch_maps']
self.maps = args['maps']
self.game_args = args['game_args']
self._game = vizdoom.DoomGame()
#self._game.set_vizdoom_path(os.path.join(vizdoom_path,'bin/vizdoom'))
#self._game.set_doom_game_path(os.path.join(vizdoom_path,'bin/freedoom2.wad'))
self._game.load_config(self.config)
self._game.add_game_args(self.game_args)
self.curr_map = 0
#if not self.multiplayer:
self._game.set_doom_map(self.maps[self.curr_map])
# set resolution
try:
self._game.set_screen_resolution(getattr(vizdoom.ScreenResolution, 'RES_%dX%d' % self.resolution))
self.resize = False
except:
print("Requested resolution not supported:", sys.exc_info()[0], ". Setting to 160x120 and resizing")
self._game.set_screen_resolution(getattr(vizdoom.ScreenResolution, 'RES_160X120'))
self.resize = True
# set color mode
if self.color_mode == 'RGB':
self._game.set_screen_format(vizdoom.ScreenFormat.CRCGCB)
self.num_channels = 3
elif self.color_mode == 'GRAY':
self._game.set_screen_format(vizdoom.ScreenFormat.GRAY8)
self.num_channels = 1
else:
print("Unknown color mode")
raise
self.available_controls, self.continuous_controls, self.discrete_controls = self.analyze_controls(self.config)
self.num_buttons = self._game.get_available_buttons_size()
assert(self.num_buttons == len(self.discrete_controls) + len(self.continuous_controls))
assert(len(self.continuous_controls) == 0) # only discrete for now
self.num_meas = self._game.get_available_game_variables_size()
self.meas_tags = []
for nm in range(self.num_meas):
self.meas_tags.append('meas' + str(nm))
self.episode_count = 0
self.game_initialized = False
def initialize_doom(game):
game = vzd.DoomGame()
game.load_config("basic.cfg")
game.set_mode(vzd.Mode.PLAYER)
game.set_screen_format(vzd.ScreenFormat.GRAY8)
game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
game.init()
game.set_window_visible(False)
return game
def Create_environment():
game = vzd.DoomGame()
config_path = r"C:\Users\PC\Miniconda3\envs\tensorflow\Lib\site-packages\vizdoom\scenarios\basic.cfg"
game.load_config(config_path)
scenario_path = r"C:\Users\PC\Miniconda3\envs\tensorflow\Lib\site-packages\vizdoom\scenarios\basic.wad"
game.set_doom_scenario_path(scenario_path)
game.init()
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
return game, possible_actions
def measure(name, iters=5000, **settings):
print(name)
for k, v in settings.items():
print("\t{}: {}".format(k, v))
# Vizdoom wrapper
doom_wrapper = VizdoomWrapper(**settings)
start = time()
for _ in trange(iters, leave=False):
current_img, current_misc = doom_wrapper.get_current_state()
action_index = randint(0, doom_wrapper.actions_num - 1)
doom_wrapper.make_action(action_index)
if doom_wrapper.is_terminal():
doom_wrapper.reset()
end = time()
wrapper_t = (end - start)
# Vanilla vizdoom:
doom = vzd.DoomGame()
if "scenarios_path" not in settings:
scenarios_path = vzd.__path__[0] + "/scenarios"
else:
scenarios_path = settings["scenarios_path"]
config_file = scenarios_path + "/" + settings["config_file"]
doom.load_config(config_file)
doom.set_window_visible(False)
doom.set_screen_format(vzd.ScreenFormat.GRAY8)
doom.set_screen_resolution(vzd.ScreenResolution.RES_160X120)
doom.init()
actions = [
list(a)
for a in it.product([0, 1],
repeat=len(doom.get_available_game_variables()))
]
start = time()
frame_skip = settings["frame_skip"]
for _ in trange(iters, leave=False):
if doom.is_episode_finished():
doom.new_episode()
doom.make_action(choice(actions), frame_skip)
end = time()
vanilla_t = end - start
print(green("\twrapper: {:0.2f} steps/s".format(iters / wrapper_t)))
print(
green("\twrapper: {:0.2f} s/1000 steps".format(wrapper_t / iters *
1000)))
print(blue("\tvanilla: {:0.2f} steps/s".format(iters / vanilla_t)))
print(
blue("\tvanilla: {:0.2f} s/1000 steps\n".format(vanilla_t / iters *
1000)))
def __init__(self, cfg):
super(VizDoom, self).__init__()
# Global vars
self.skiprate = cfg.skiprate
self.num_channels = cfg.num_channels
self.resolution = cfg.resolution
self.terminal = np.zeros(
[self.resolution[0], self.resolution[1], cfg.num_channels])
# Init game, set params
self.game = vzd.DoomGame()
# Scenario
self.game.set_doom_scenario_path(cfg.vizdoom_dir +
"/scenarios/basic.wad")
self.game.set_doom_map("map01")
# Screen
self.game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
self.game.set_screen_format(vzd.ScreenFormat.RGB24)
self.game.set_window_visible(True)
self.game.set_sound_enabled(True)
# Buffers
#self.game.set_depth_buffer_enabled(True)
#self.game.set_labels_buffer_enabled(True)
#self.game.set_automap_buffer_enabled(True)
# Rendering
self.game.set_render_hud(False)
self.game.set_render_minimal_hud(False) # If HUD enabled
self.game.set_render_crosshair(False)
self.game.set_render_weapon(False)
self.game.set_render_decals(
False) # Bullet holes and blood on the walls
self.game.set_render_particles(False)
self.game.set_render_effects_sprites(False) # Smoke and blood
self.game.set_render_messages(False) # In-game messages
self.game.set_render_corpses(False)
self.game.set_render_screen_flashes(
True) # Effect upon taking damage or picking up items
# Actions
self.game.set_available_buttons(
[vzd.Button.MOVE_LEFT, vzd.Button.MOVE_RIGHT, vzd.Button.ATTACK])
# Variables included in state
self.game.set_available_game_variables([vzd.GameVariable.AMMO2])
# Start/end time
self.game.set_episode_start_time(14)
self.game.set_episode_timeout(300)
# Reward
self.game.set_living_reward(-1)
self.game.set_doom_skill(5)
# Game mode
self.game.set_mode(vzd.Mode.PLAYER)
self.game.init()
def init_watching_environment(configuration):
print("Initializing doom...")
game = vzd.DoomGame()
game.load_config(configuration)
game.set_window_visible(True)
game.set_mode(vzd.Mode.ASYNC_PLAYER)
game.set_screen_format(vzd.ScreenFormat.GRAY8)
game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
n = game.get_available_buttons_size()
actions = [list(a) for a in it.product([0, 1], repeat=n)]
game.init()
print("Doom initialized. It's time to watch!")
return game, actions
def setup_game_test(wad):
game = vzd.DoomGame()
# Use your config
game.load_config(DEFAULT_CONFIG)
# Set Scenario to the new generated WAD
game.set_doom_scenario_path(wad)
# Sets up game for spectator (you)
game.set_window_visible(True)
game.set_mode(vzd.Mode.PLAYER)
game.set_render_hud(False)
# Set cv2 friendly format.
game.set_screen_format(vzd.ScreenFormat.BGR24)
# Enables rendering of automap.
game.set_automap_buffer_enabled(True)
game.set_labels_buffer_enabled(True)
game.set_depth_buffer_enabled(True)
# All map's geometry and objects will be displayed.
game.set_automap_mode(vzd.AutomapMode.OBJECTS_WITH_SIZE)
game.add_available_game_variable(vzd.GameVariable.POSITION_X)
game.add_available_game_variable(vzd.GameVariable.POSITION_Y)
game.add_available_game_variable(vzd.GameVariable.POSITION_Z)
game.add_available_game_variable(vzd.GameVariable.ANGLE)
game.add_available_game_variable(vzd.GameVariable.PITCH)
game.add_available_game_variable(vzd.GameVariable.ROLL)
game.add_available_game_variable(vzd.GameVariable.VELOCITY_X)
game.add_available_game_variable(vzd.GameVariable.VELOCITY_Y)
game.add_available_game_variable(vzd.GameVariable.VELOCITY_Z)
# This CVAR can be used to make a map follow a player.
game.add_game_args("+am_followplayer 1")
# This CVAR controls scale of rendered map (higher valuer means bigger zoom).
game.add_game_args("+viz_am_scale 3")
game.add_game_args("+am_showthingsprites 3")
game.add_game_args("+am_cheat 1")
game.add_game_args("+sv_cheats 1")
game.init()
game.send_game_command("iddqd")
return game
def create_env(game_state_only=False, actions_only=False, render_screen=False):
"""
Sets up the game environment
"""
scenarios = '/usr/local/lib/python3.7/dist-packages/vizdoom/scenarios/'
# global GAME
doom = vz.DoomGame()
doom.load_config(os.path.join(scenarios, 'basic.cfg')) # Config
doom.set_doom_scenario_path(os.path.join(scenarios,
'basic.wad')) # Scenario
if game_state_only:
return doom
return initialize_game(doom, render_screen, actions_only=actions_only)
def configure_game_training(self):
print("Initializing game environment...")
game = vizdoom.DoomGame()
game.load_config("basic.cfg")
game.set_window_visible(False)
game.set_screen_format(vizdoom.ScreenFormat.GRAY8)
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
print("Finished game environment!")
return game, possible_actions
def test_get_state():
print("Testing get_state() ...")
episodes = 10000
episode_timeout = 1000
buttons = [vzd.Button.MOVE_FORWARD, vzd.Button.MOVE_BACKWARD,
vzd.Button.MOVE_LEFT, vzd.Button.MOVE_RIGHT,
vzd.Button.TURN_LEFT, vzd.Button.TURN_RIGHT,
vzd.Button.ATTACK, vzd.Button.USE]
actions = [list(i) for i in product([0, 1], repeat=len(buttons))]
game = vzd.DoomGame()
game.set_window_visible(False)
game.set_episode_timeout(episode_timeout)
game.set_available_buttons(buttons)
game.init()
prev_mem = 0
prev_len = 0
mem_eta = 1
for i in range(episodes):
game.new_episode()
states = []
states_copies = []
while not game.is_episode_finished():
state = game.get_state()
states.append(state.screen_buffer)
states_copies.append(np.copy(state.screen_buffer))
game.make_action(choice(actions), 4)
# Compare states with their copies
for s, s_copy in zip(states, states_copies):
assert np.array_equal(s, s_copy)
# Check memory
process = psutil.Process(os.getpid())
mem = process.memory_info().rss / 1024 / 1024
if i % 100 == 0:
print("Memory, with {} states saved, after episode {} / {}: {} MB".format(len(states), i, episodes, mem))
if prev_len < len(states):
prev_mem = mem
prev_len = len(states)
elif prev_len == len(states):
assert abs(prev_mem - mem) < mem_eta
def __init__(self, level=0, enable_sound=False):
# tue.
self.enable_sound = enable_sound
self.is_initialized = False
self.screen_height = 480
self.screen_width = 640
self.observation_space = spaces.Box(low=0, high=255, shape=(self.screen_height, self.screen_width, 3))
self.game = vizdoom.DoomGame()
self.accumulated_reward = 0
self.curr_seed = 0
self.mode = CPU # or human
self.level = level
self.reset() # load buttons, etc.
def setup_player():
game = vzd.DoomGame()
game.load_config(config)
game.set_mode(mode)
game.add_game_args(args)
game.set_screen_resolution(resolution)
game.set_console_enabled(console)
game.set_window_visible(window)
game.set_ticrate(ticrate)
actions = [[1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0, 0]]
return game, actions
def __init__(self, args):
self.config = args['config']
self.resolution = args['resolution']
self.frame_skip = args['frame_skip']
self.color_mode = args['color_mode']
self.game_args = args['game_args']
self._game = vizdoom.DoomGame()
self._game.load_config(self.config)
self._game.add_game_args(self.game_args)
if 'ticrate' in args:
self._game.set_ticrate(args['ticrate'])
# set resolution
try:
self._game.set_screen_resolution(
getattr(vizdoom.ScreenResolution,
'RES_%dX%d' % self.resolution))
except:
print("Requested resolution not supported:", sys.exc_info()[0])
raise
# set color mode
if self.color_mode == 'RGB':
self._game.set_screen_format(vizdoom.ScreenFormat.CRCGCB)
self.num_channels = 3
elif self.color_mode == 'RGB24':
self._game.set_screen_format(vizdoom.ScreenFormat.RGB24)
self.num_channels = 3
elif self.color_mode == 'GRAY':
self._game.set_screen_format(vizdoom.ScreenFormat.GRAY8)
self.num_channels = 1
else:
print("Unknown color mode")
print("Simulator: colour format: ", self.color_mode)
self.available_controls, self.continuous_controls, self.discrete_controls = self.analyze_controls(
self.config)
self.num_buttons = self._game.get_available_buttons_size()
assert (self.num_buttons == len(self.discrete_controls) +
len(self.continuous_controls))
# assert (len(self.continuous_controls) == 0) # only discrete for now
self.num_meas = self._game.get_available_game_variables_size()
self.game_initialized = False
def _init_game(self):
self.close()
game = vd.DoomGame()
game = player_setup(game, self.cfg)
if self.cfg.is_multiplayer_game:
if self.cfg.host_cfg is not None:
game = player_host_setup(game, self.cfg.host_cfg)
elif self.cfg.join_cfg is not None:
game = player_join_setup(game, self.cfg.join_cfg)
else:
raise ValueError('neither host nor join, error!')
game.init()
self.game = game
self._game_var_list = self.game.get_available_game_variables()
self._update_vars()
def create_env(visible=False):
"""
Creates an instance of the game environment
"""
path = '/usr/local/lib/python3.7/dist-packages/vizdoom/scenarios/'
doom = vz.DoomGame()
doom.load_config(os.path.join(path, 'deadly_corridor.cfg'))
doom.set_doom_scenario_path(os.path.join(path, 'deadly_corridor.wad'))
doom.set_window_visible(visible)
doom.init()
actions = np.identity(doom.get_available_buttons_size())
return doom, actions
def _init_game(self):
self.close()
game = vd.DoomGame()
game = player_setup(game, self.cfg)
if self.cfg.is_multiplayer_game:
if self.cfg.host_cfg is not None:
game = player_host_setup(game, self.cfg.host_cfg)
elif self.cfg.join_cfg is not None:
game = player_join_setup(game, self.cfg.join_cfg)
else:
raise ValueError('neither host nor join, error!')
game.init()
self.game = game
def initialize_vizdoom(config_file_path, seed):
print("Initializing doom...")
game = vzd.DoomGame()
game.load_config(config_file_path)
game.set_window_visible(True)
game.set_labels_buffer_enabled(True)
game.add_available_game_variable(vzd.GameVariable.HEALTH)
# game.set_mode(vzd.Mode.PLAYER)
game.set_mode(vzd.Mode.SPECTATOR)
game.set_screen_format(vzd.ScreenFormat.GRAY8)
game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
# TO-DO: set seed
game.set_seed(seed)
game.init()
print("Doom initialized.")
return game
def __init__(self, WAD_FILE='wad_files/test_6.wad', visible=False):
CONFIG = "standard_config.cfg"
#WAD_FILE
self.game = vzd.DoomGame()
self.game.load_config(CONFIG)
self.game.set_doom_map("map01")
self.game.set_doom_skill(2)
# This line connects to the actual wad file we just generated
self.game.set_doom_scenario_path(WAD_FILE)
# Sets up game for spectator (you)
# Do I want this for RL env, need to look into it
#self.game.add_game_args("+freelook 1")
self.game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
self.game.set_window_visible(visible)
#self.game.set_mode(vzd.Mode.SPECTATOR)
self.game.set_mode(vzd.Mode.PLAYER)
self.game.add_available_game_variable(vzd.GameVariable.POSITION_X)
self.game.add_available_game_variable(vzd.GameVariable.POSITION_Y)
self.game.init()
self.game.set_doom_map("map{:02}".format(1))
self.game.new_episode()
self.max_ep_steps = 2000
self.action_list = [[0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, 0, 1, 0, 0],
[1, 0, 0, 0, 1, 0, 0, 0], [1, 0, 0, 1, 0, 1, 0, 0],
[1, 0, 0, 1, 1, 0, 0, 0], [1, 0, 0, 0, 0, 1, 1, 0],
[1, 0, 0, 0, 0, 1, 0, 1], [1, 0, 0, 0, 1, 0, 1, 0],
[1, 0, 0, 0, 1, 0, 0, 1], [0, 1, 0, 0, 0, 1, 0, 0],
[0, 1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 1, 0],
[0, 1, 0, 0, 0, 1, 0, 1], [0, 1, 0, 0, 1, 0, 1, 0],
[0, 1, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0, 1, 0]]
def __init__(self, behaviour, server=False, map_name="map01", players=2):
self.behaviour = behaviour
self.is_server = server
# init game
self.game = vizdoom.DoomGame()
scenarios_dir = os.path.join(os.path.dirname(__file__), 'scenarios')
self.game.load_config(os.path.join(scenarios_dir, 'duel.cfg'))
self.game.set_window_visible(False)
self.map_name = map_name
self.game.set_doom_map(map_name)
if server:
self.game.add_game_args("-host {} "
"-deathmatch "
"+timelimit 15.0 "
"+sv_forcerespawn 1 "
"+sv_noautoaim 1 "
"+sv_respawnprotect 1 "
"+sv_spawnfarthest 1 "
"+sv_nocrouch 1 "
"+viz_respawn_delay 5 ".format(players))
else:
self.game.add_game_args("-join 127.0.0.1")
self.game.set_mode(vizdoom.Mode.PLAYER)
self.behaviour.init(self.game)
init_passed = False
while not init_passed:
try:
self.game.init()
init_passed = True
except vizdoom.ViZDoomUnexpectedExitException as e:
print(
'Exception caught while initializing the game! Retrying...'
)
time.sleep(0.5)
self.action_space = self.behaviour.action_space
self.observation_space = self.behaviour.observation_space
self.viewer = None
def __init__(self, params):
super().__init__()
try:
import vizdoom
from argparse import ArgumentParser
except:
print(
"Failed to import ViZDoom, make sure you have ViZDoom installed!"
)
# Check if config is sent in params
if 'config' in params:
DEFAULT_CONFIG = params['config']
# If not, pull config from env_name
else:
file_path = 'AIQ/test_suite/VizDoom/vizdoom_scenarios/'
# Input --> env_name = vizdoom_stuff_name
DEFAULT_CONFIG = file_path + params['env_name'] + '.cfg'
self.env = vizdoom.DoomGame()
# Incase cfg path is incorrect
try:
self.env.load_config(DEFAULT_CONFIG)
except Exception as inst:
print(inst)
print(DEFAULT_CONFIG)
# This will disable popup window for vizdoom
# Should allow it to work in docker
self.env.set_window_visible(False)
self.env.set_sound_enabled(False)
# Define header
self.header = header(env_name="ViZDoom_" + params['env_name'],
input_dim=[len(self.env.get_available_buttons())],
output_dim=[
self.env.get_screen_channels(),
self.env.get_screen_height(),
self.env.get_screen_width(),
],
info="ViZDoom simulator",
env_min_score=-200.0,
env_max_score=100.0,
rl=True)
def __init__(self, render=False, config_path='surprise/envs/vizdoom/scenarios/take_cover.cfg', vae=False, god=True, respawn=True):
#def __init__(self, render=False, config_path='/home/dangengdg/minimalEntropy/tree_search/vizdoom/scenarios/take_cover.cfg', vae=False, god=True, respawn=True):
# Start game
self.game = vzd.DoomGame()
# Set sleep time (for visualization)
self.sleep_time = 0
self.game.set_window_visible(render)
self.sleep_time = .02 * int(render)
# Game Configs
self.game.load_config(config_path)
self.game.set_screen_resolution(vzd.ScreenResolution.RES_640X480)
self.game.set_render_screen_flashes(True) # Effect upon taking damage
self.episode_length = 1000
self.skiprate = 2
self.game.set_episode_timeout(self.episode_length * self.skiprate)
# Initialize the game
self.game.init()
# Actions are left or right
self.actions = [[True, False], [False, True]]
# Env Variables
self.done = False
self.time = 1
self.downsample_factor = .02
self.obs_hist = [self.get_random_state(res=48*64) for _ in range(4)]
self.god = god
self.respawn = respawn
self.fireball = 0
self.in_fireball = 0
# Buffer
self.buffer = [self.get_random_state(10*13) for _ in range(2)]
self.vae = None
if vae:
self.vae = VAE().to(0)
chkpt = torch.load('/home/dangengdg/minimalEntropy/tree_search/vizdoom/checkpoints/vae.pth')
self.vae.load_state_dict(chkpt['state_dict'])
# Spaces
self.action_space = spaces.Discrete(2)
self.observation_space = spaces.Box(0, self.episode_length, shape=(12289,))
self.reset()
def create_env(visible=False, scene=''):
"""
Creates an instance of the game environment
"""
path = '/usr/local/lib/python3.7/dist-packages/vizdoom/scenarios/'
scene = 'defend_the_center' if not scene else scene
doom = vz.DoomGame()
doom.load_config(os.path.join(path, f'{scene}.cfg'))
doom.set_doom_scenario_path(os.path.join(path, f'{scene}.wad'))
doom.set_window_visible(visible)
doom.init()
actions = np.identity(doom.get_available_buttons_size(), dtype=np.bool)
return doom, actions
def initialize_vizdoom():
vizdoom_home = os.path.split(vizdoom.__file__)[0]
game = vizdoom.DoomGame()
game.load_config(FLAGS.config)
game.set_doom_game_path(f"{vizdoom_home}/doom2.wad")
game.set_doom_scenario_path(f"{vizdoom_home}/scenarios/basic.wad")
game.set_window_visible(False)
game.set_sound_enabled(FLAGS.skip_training)
game.set_mode(vizdoom.Mode.PLAYER)
game.set_screen_format(vizdoom.ScreenFormat.GRAY8)
game.set_screen_resolution(vizdoom.ScreenResolution.RES_640X480)
game.init()
return game
def _test_enums(enum_name, func_name):
print("Testing vzd.{} enum ...".format(enum_name))
game = vzd.DoomGame()
game.set_window_visible(False)
add_func = eval("game.add_" + func_name)
get_func = eval("game.get_" + func_name + "s")
set_func = eval("game.set_" + func_name + "s")
clear_func = eval("game.clear_" + func_name + "s")
all_values = [
eval("vzd." + enum_name + "." + v)
for v in dir(eval("vzd." + enum_name))
if not v.startswith('__') and not v == 'name' and not v == 'value'
]
all_values_names = [v.name for v in all_values]
# set test
set_func(all_values)
get_buttons_names = [v.name for v in get_func()]
assert all_values_names == get_buttons_names
# add test
clear_func()
for i, v in enumerate(all_values):
add_func(v)
get_values_names = [v.name for v in get_func()]
assert all_values_names[:i + 1] == get_values_names
# again set test
set_func(all_values)
get_values_names = [v.name for v in get_func()]
assert all_values_names == get_values_names
# multiple adds
for i, v in enumerate(all_values):
add_func(v)
get_values_names = [v.name for v in get_func()]
assert all_values_names == get_values_names
# multiple in set
set_func(all_values + all_values)
get_values_names = [v.name for v in get_func()]
assert all_values_names == get_values_names
def create_environment():
game = vzd.DoomGame()
# Load the game
game.set_doom_scenario_path("basic.wad")
game.load_config("./basic.cfg")
# Possible actions
left = [1, 0, 0]
right = [0, 1, 0]
shoot = [0, 0, 1]
possible_actions = [left, right, shoot]
game.set_window_visible(True) # Render game
game.set_screen_format(vzd.ScreenFormat.GRAY8)
game.set_screen_resolution(vzd.ScreenResolution.RES_160X120)
game.init()
return game, possible_actions
