README.md

metadata

title: Doom Environment Server
emoji: 🎮
colorFrom: blue
colorTo: green
sdk: docker
pinned: false
app_port: 8000
base_path: /web
tags:
  - openenv
  - Doom
  - vizDoom
  - Reinforcement-Learning

Doom Environment

A ViZDoom-based environment for OpenEnv. ViZDoom is a Doom-based AI research platform for visual reinforcement learning, allowing agents to play Doom using only visual information.

⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⢾⠍⡉⠉⠙⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣴⠾⠿⠽⢷⣶⣤⡀⠀⠀⠀⠀⠀⠀⠀⢀⣟⡟⣠⣿⣶⡀⣷⡻⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠴⡟⡋⡀⠀⣀⣀⠀⠀⠉⠛⣦⡀⠀⠀⠀⠀⠀⠀⢿⣅⣽⣿⣿⣷⣿⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡴⠃⢀⢾⣿⣿⣿⣯⣬⣽⣿⣀⡀⠈⠙⣆⠀⠀⠀⠀⢀⣸⣯⣿⣾⡷⢻⣿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣜⢁⠁⣾⡿⣙⠿⣯⣭⣍⣹⠼⠋⠁⣴⠀⢘⣧⠀⠀⡴⢛⣭⢟⠽⠋⢠⣼⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⢻⠘⢸⡿⢷⣬⣧⡀⠀⠀⠀⢀⣤⠾⢿⡇⠘⣿⡆⣸⠛⣿⡿⣟⡀⠀⡾⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣾⣦⣿⣿⡄⠈⢿⢿⣷⣶⡾⠋⠁⠀⣸⠇⡰⠛⢷⣷⣻⡿⠺⣿⣿⠽⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣀⣀⣀⠀⣴⠏⠀⣿⠙⢻⣿⣄⠈⠀⠸⠀⠉⠀⣠⣾⠟⢀⣧⡇⠀⢽⣿⣿⣬⣼⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⠚⣿⣿⣿⣿⣿⡿⠟⢛⣰⣿⣧⣷⣝⡿⣷⣞⢷⣄⣲⣾⣿⡃⢰⡿⡟⢀⣴⣿⣿⣿⣯⡿⠿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⠞⢁⣼⣿⣿⣿⡟⠋⠁⣉⣽⣿⣿⣿⣿⣿⣽⣯⣿⡄⠉⠁⢷⣬⣹⣿⣿⣤⡾⠁⣸⣿⣿⡟⠁⠀⠀⢹⣿⣿⣷⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡷⠞⣫⣾⣿⣿⣿⣧⡀⣤⠀⠈⣻⣿⣿⣿⣿⣿⣿⣿⣷⣖⠀⠘⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠃⠋⠻⢤⣅⡺⢦⡀⠳⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣯⣴⠞⠁⣀⣿⣿⣿⣿⣷⣄⣤⠤⢊⣿⣿⣿⣿⣿⣿⣿⣿⣯⣴⣴⣶⣿⣿⠟⣸⣿⣿⣿⣿⡏⡆⠀⢠⣤⣠⣥⠀⡟⣶⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⣽⡿⣿⣏⡀⠀⠹⣟⣿⡿⣿⣿⣋⣶⣺⡽⣿⣏⣅⠛⠂⠴⠶⠿⠿⠃⠈⠉⠻⣷⣶⣿⣿⣿⣿⡿⠀⣿⡄⠈⣷⣮⠙⢀⡿⠘⢻⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⢸⣧⢻⡶⠀⠀⠘⢿⣿⣿⣿⣿⣿⠋⠉⠀⠀⠉⠻⠿⠶⠶⠶⠦⠴⠞⠛⠷⠗⠈⠛⢿⣿⣿⡿⢁⣼⠯⠄⠀⠀⠀⣠⡞⠁⣠⣾⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⢸⣻⣾⣷⡀⢐⠀⣿⣿⣿⣿⣿⠁⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡁⠰⣾⣿⠀⠀⠈⢻⣿⣅⢿⣇⠀⠀⠀⠀⢀⣿⡟⠀⡷⢿⢿⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⡎⣤⣌⡰⣿⣿⣿⣿⣟⠀⠠⠀⢀⡀⠀⠂⠀⠀⠉⠉⠉⠈⠉⠙⢾⣭⡤⠂⠀⠀⠹⣿⣎⣿⣶⣒⣿⣷⣿⣯⣮⡵⣿⣾⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⢿⠛⣿⠛⠛⢿⣿⣿⣃⢀⣀⣀⠀⣀⣤⣾⠓⠶⠖⠷⣤⣄⡀⠀⠀⠀⠀⠀⠀⢠⣿⣿⣾⣿⣿⣿⠍⣩⣉⣿⡆⠰⣿⣭⡇⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡸⠾⢴⡇⠀⠀⢸⣿⣿⣯⣭⣿⣿⣿⡿⠛⠛⠛⠛⠛⠛⠛⠟⠻⣷⣶⣴⣶⣮⡴⠫⢾⣿⣿⣟⠉⣹⣿⣿⣿⣿⣷⣄⠸⢿⡇⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⠋⡽⠁⡾⠀⠀⠀⣼⣿⣧⣁⣴⣶⠾⢿⣿⡶⠀⠒⠒⠂⠀⠀⠀⣰⣾⣧⣌⣉⠙⠂⢠⢿⣿⣿⣫⡿⠿⠋⠉⠈⠙⢻⣽⢧⠀⣽⣄⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⢀⣴⡻⣻⣼⣿⣰⠇⠀⠀⠀⠉⣁⣿⣟⢉⣼⣶⣶⡿⠿⣿⡟⠛⠛⠛⣷⣾⢿⣯⣤⣤⡉⠳⡶⢋⡞⣿⣿⣇⠀⠀⠙⠀⠀⠀⢀⣿⣫⠇⣈⣁⣣⡀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⣠⠎⠉⣰⣿⣿⣿⠉⢲⣤⠀⠀⠾⣿⣿⣳⣜⢿⡟⠫⢠⣶⣾⣷⣤⣤⣼⣯⡤⣤⣀⣻⠻⣿⣦⣠⠞⣼⣿⡿⢿⣤⡸⣷⣦⣤⣴⣿⣿⣯⠼⢥⣈⣿⡗⠶⢤⡀⠀⠀ ⠀⠀⠀⠀⢰⡃⠀⣼⣿⣿⣿⣿⣷⣤⣁⣀⣤⣾⣿⣿⣿⣿⣿⣿⠷⣾⣟⣀⣫⣄⣀⣀⣠⣄⠘⢿⡤⠴⣷⡿⠃⠘⡽⣿⣃⠘⣿⣿⣿⣿⣿⣿⣿⠿⡿⠟⠀⠘⣝⢿⡆⠀⠻⣦⡀ ⠀⠀⠀⢀⡏⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢳⣿⣯⣿⣿⣿⡿⣾⣿⡏⠙⣿⡉⠙⡍⠉⢿⣟⣴⠶⠾⢿⣟⠷⣿⡿⠿⣷⣾⡇⢻⣿⣿⡏⡴⠞⠻⣞⡍⠙⢫⣿⣧⠀⠀⠘⠃ ⠀⠀⢀⣾⢿⡾⢷⣿⣿⠋⣿⣿⣿⣿⣿⣿⣿⡗⣼⢿⣿⣿⠘⣿⣿⣷⣼⣣⣶⠾⠿⠛⠶⣦⠚⣠⣴⣿⣿⠋⢰⣼⣯⠁⠐⢺⣿⣿⣮⣿⣿⣿⡟⠂⢀⣽⡓⡀⠒⢹⣿⠇⠀⣤⡀ ⠀⠀⣿⠿⣾⣳⣼⣏⠛⠛⢿⣯⣶⣿⢋⣼⣿⢱⣟⣷⣮⠻⣷⠘⠿⣿⣭⣉⡉⣠⣤⣤⣄⣉⣉⣁⣾⡿⠟⣠⣾⡏⣡⠎⠀⢸⣿⡌⣿⣿⣿⣿⣟⡂⠠⢿⡅⢨⡏⣾⣟⠀⠀⠈⠁ ⠀⢸⡿⠓⢀⣿⣿⣿⡷⣦⣼⠟⣹⡵⠛⢳⢟⣾⣿⣿⡿⠀⣿⠄⡀⣿⣯⠙⣿⡟⠛⢛⠛⣿⣿⡏⢉⡇⠀⢯⣿⡇⡅⢴⠀⢸⣾⡇⠸⣟⠹⣿⢿⡏⢰⣿⣆⣈⠁⣽⣿⠀⠀⠀⠀ ⢀⡖⠘⠃⢠⣿⣯⡟⠻⣿⣻⡟⠃⠀⠀⠸⣿⢿⣿⣿⣿⣾⣿⣿⣿⣿⣿⣧⢸⣧⣤⣭⣤⣿⣿⡔⢿⣿⡿⣿⣿⣿⣷⣤⣠⣿⣿⠃⠀⣿⣇⣿⣿⣷⣿⣿⠿⢽⣷⣩⣿⠀⠀⠀⠀ ⣾⠁⣠⠹⣿⣿⡟⠻⣶⣿⢻⡇⠀⠀⠀⠀⠈⢹⡿⣿⣿⣿⣿⢟⣟⢿⢿⣿⣿⡷⠶⠶⠶⠈⢯⡻⡄⢻⣿⢀⠙⢿⣿⣿⣷⡟⠁⢀⣴⢟⣺⣿⣿⣿⣥⣽⣶⣄⣈⣿⣿⠀⠀⠀⠀ ⣭⠎⠿⢠⡟⢿⣿⣷⣽⣿⣼⡇⠀⠀⠀⠀⢠⣿⢿⡛⢿⡿⣿⡾⣿⡇⢠⣿⣿⡇⠀⠀⠀⠀⣈⢻⡖⢸⣿⢿⣾⢏⠟⠛⢿⣧⣀⣸⣴⡿⢻⣿⣻⣍⠉⣉⠛⣛⠛⠛⢿⡷⠀⠀⢀ ⢳⣶⠖⠈⢿⣿⣛⠹⣿⣿⢸⡃⠀⠀⠀⣠⠟⣩⠞⠀⠈⣿⡟⣵⡿⠃⣼⣿⣿⠁⠐⠀⠘⠃⠉⣸⣇⠀⠹⣦⢻⣟⠀⠀⠀⠹⣿⣴⣯⣼⣿⣿⣿⣿⡄⣿⡀⢿⣰⡇⢸⡇⠀⠠⠋ ⠸⣹⡶⠀⢸⣿⣿⣿⣷⣛⢻⡇⠀⠀⢠⡷⠃⠁⠀⠀⠀⣿⠸⣿⠀⠠⣿⣿⣧⡀⠀⠀⠀⠀⢰⣿⣄⠁⠀⣹⢦⣿⣦⠀⠀⠀⣿⣿⣿⡏⣿⡏⡛⠟⢲⣶⢶⣾⣷⡭⣸⡴⠊⠀⠀ ⠀⢹⡄⣄⡘⣿⣿⣿⣿⠹⡿⠁⠀⠀⣿⠇⠀⠀⠀⠀⡶⠘⡇⣿⡃⠂⣻⣿⣿⣷⡄⠀⠀⠀⢸⣿⣝⡓⢰⣿⣾⡏⣿⣦⠀⠀⢹⣾⣿⡎⢰⣷⣓⠀⣼⣿⢸⣿⢹⡆⢿⠇⠀⠀⠀ ⠀⠀⠙⠻⣿⣿⠧⠭⠭⠟⠁⠀⠀⣸⡽⢐⠀⠀⠀⢸⣇⣸⡷⣿⠃⠀⢿⣿⣿⣿⣿⣿⣷⣦⣿⣿⣯⡟⢺⣿⣿⣇⣸⡿⡇⠀⢀⡟⣿⡧⢸⣷⡌⢀⣿⣿⣼⣿⠮⣿⠋⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠈⠁⠀⠀⠀⠀⠀⢀⣟⣷⡿⠀⠀⠀⠀⠉⢸⡇⡷⠀⢀⠈⠻⣿⣿⢿⣿⢿⣿⣿⣿⣿⣷⣾⣿⣿⡇⠉⠀⠀⠀⢸⡇⢸⣿⡾⡿⣧⣼⣿⠵⣿⣇⡾⠁⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣾⣼⡛⢸⡄⠀⠀⠀⢸⣧⢳⣀⠀⠀⠀⣿⢋⡟⠈⢧⢻⣿⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀⠈⡇⠀⢯⡇⠀⠉⠙⠙⠉⠉⠋⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⢹⡸⣷⠀⠀⠀⠄⠻⢷⣄⣀⢀⣼⣣⠟⠀⠀⠈⢣⠹⣿⣿⣿⣿⣿⣿⠿⢷⡄⠀⠀⠀⠀⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⡈⢁⣽⣷⡆⠀⠀⠀⠀⢈⣽⣿⡿⠃⠀⠀⠀⠀⠀⠙⣌⢻⣿⣿⣿⣿⠀⠈⢿⣦⠓⠀⠀⠀⣸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠚⢿⣷⣿⣿⣯⣻⡄⠀⠀⢀⣾⠟⡿⠁⠀⠀⠀⠀⠀⠀⠀⠈⢦⡻⣿⣿⣷⡀⢠⣾⣫⡿⣬⡃⠆⠛⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣻⣷⢾⣟⠛⠁⠉⢻⣿⣆⣠⡾⢿⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣇⣸⣿⣿⣾⣾⣿⠇⠀⠈⢙⡟⠿⢻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣫⡾⠿⣦⣀⣀⣠⡿⢿⣏⡴⣿⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣿⣿⣿⣿⣿⣤⣤⣤⡞⠁⢂⣹⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣉⣿⡳⠀⠀⠈⠁⠀⠀⠈⢿⡄⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⢿⣿⣿⣿⣷⣄⠀⠀⠀⢀⡀⠘⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣰⣷⣻⣿⡟⠶⠶⠤⠤⠀⠀⠀⣸⣿⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣿⣿⣿⣶⣖⣾⠭⡁⠈⢿⣳⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⢰⣟⣿⣽⠋⣿⠃⢤⣭⣭⠀⠀⠀⣠⣟⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⡿⣿⣿⣿⣿⣯⡥⠶⠀⣛⠀⢶⡿⡬⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⣶⡿⢱⣿⣰⡿⠿⠶⢭⣦⠀⠀⣰⡿⢁⢿⣾⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⣢⣿⣿⣿⣿⣷⣶⠖⠛⠙⢷⣌⡉⠹⣷⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⢰⣿⣗⣿⣿⣿⡀⣶⣶⠀⣹⣷⣾⣿⣷⡼⣯⣿⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⢿⣿⣿⣿⣿⣿⣿⣿⣗⣼⠄⠀⣿⣷⣀⣿⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠈⢹⣿⡿⢻⣿⣷⣽⣏⣰⣿⣿⣿⣷⣶⣧⢹⣷⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠸⣭⠿⣿⣿⣿⣿⣿⣿⣿⣿⣥⣤⣾⠏⠻⡇⣿⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⢿⣿⣿⣟⠻⠿⠿⠛⠹⣿⣿⣿⣿⣾⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⡇⣻⣿⣿⣿⣿⣿⡍⠛⠛⠋⠁⠀⣀⢿⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⢸⡿⣿⣿⣿⣿⡗⠓⣤⠀⢀⣤⣿⢃⣸⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢿⠻⣿⣿⣿⣿⣿⣏⣹⣧⢀⣾⡉⢸⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⠀⣼⡿⣿⣿⣿⣛⠁⠘⡋⠙⣋⣥⣿⢾⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢣⡜⣿⣿⣿⣿⡏⠛⢩⡉⠀⡛⢸⣿⢷⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⢀⣿⣷⣿⣿⣿⣯⣤⡤⡒⣛⣭⣭⢾⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⢹⣿⣿⣿⣿⡦⠼⣷⠚⣩⠏⠹⣯⡀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⠀⣿⡅⢠⣿⣿⣿⣧⣤⠾⠟⢛⣫⡵⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣳⢿⣿⣿⣿⣿⡶⣿⡞⠋⠀⠀⢻⣧⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⢰⣿⢡⢿⣿⣿⣿⣀⡀⠚⣠⣼⠁⢀⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣇⣼⣿⣿⣿⣿⣇⣼⣷⣶⣿⠟⠀⣿⣇⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠀⣞⠇⣶⣷⣬⣭⣉⣛⢛⣛⠉⣩⡷⢾⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡯⢽⣿⣿⣿⣿⣟⣉⣩⣤⡤⠶⠂⠸⣾⡄⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⣾⣿⡷⣿⣽⣾⣟⣿⣭⠈⠁⠀⣿⣠⣼⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣷⢦⣿⣿⣿⣿⣿⣯⣁⣾⣷⣶⣿⠣⣷⣵⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⢀⣾⢻⠤⠟⠓⠚⠻⢧⣀⠀⠀⠀⠙⣿⣿⣯⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⢻⣿⣿⢡⠿⠛⠋⠉⠩⠀⠀⠀⠒⠄⠞⣦⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⢸⣷⣴⢞⣏⣀⠀⡀⠀⣹⣦⠾⠟⢂⡍⠻⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢨⠿⢛⣿⡶⢷⣤⣄⣀⣀⡀⢠⣴⣀⠠⡼⣿⡁⠀⠀⠀⠀ ⠀⠀⠀⠀⢘⡃⢰⠀⡀⠀⠀⢀⡀⠀⠀⠈⠀⠀⢩⠈⣽⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣼⣿⣿⡀⣀⠒⣿⣿⠇⠀⠀⠀⠀⡀⡇⠘⣿⡀⠀⠀⠀ ⠀⠀⠀⠀⠀⡇⢸⠈⠁⠀⠀⢸⡇⠀⡇⠀⢖⣔⣾⣾⡋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠑⣟⢿⣀⣿⣾⢿⣿⡇⠈⠁⠀⠀⠀⣿⣤⣧⠇⠀⠀⠀

Overview

This environment wraps ViZDoom scenarios and exposes them through the OpenEnv API. It provides:

• Visual observations: RGB or grayscale screen buffers
• Game variables: Health, ammo, kills, etc.
• Flexible action space: Discrete actions or button combinations
• Multiple scenarios: Built-in scenarios like "basic", "deadly_corridor", "defend_the_center", etc.

Quick Start

The simplest way to use the Doom environment is through the DoomEnv class:

from doom_env import DoomAction, DoomEnv

try:
    # Create environment from Docker image
    doom_env = DoomEnv.from_docker_image("doom-env:latest")

    # Reset to start a new episode
    result = doom_env.reset()
    print(f"Screen shape: {result.observation.screen_shape}")
    print(f"Available actions: {result.observation.available_actions}")

    # Take actions
    for i in range(100):
        # Use discrete action (e.g., 0=no-op, 1-7=various actions)
        result = doom_env.step(DoomAction(action_id=1))

        # Optional: Render the game
        doom_env.render()  # Shows visualization window

        print(f"Step {i}:")
        print(f"  Reward: {result.reward}")
        print(f"  Done: {result.observation.done}")

        if result.observation.done:
            print("Episode finished!")
            break

finally:
    # Always clean up
    doom_env.close()

That's it! The DoomEnv.from_docker_image() method handles:

• Starting the Docker container
• Waiting for the server to be ready
• Connecting to the environment
• Container cleanup when you call close()

Web Interface

The Doom environment includes a built-in web interface for interactive testing and exploration. The web interface is enabled by default in the Docker image.

# Start the container with web interface (default)
docker run -p 8000:8000 doom-env:latest

# Or explicitly enable it
docker run -p 8000:8000 -e ENABLE_WEB_INTERFACE=true doom-env:latest

# Disable web interface (API only)
docker run -p 8000:8000 -e ENABLE_WEB_INTERFACE=false doom-env:latest

# Access the web interface in your browser:
# - Interactive UI: http://localhost:8000/web
# - API Documentation: http://localhost:8000/docs
# - Health Check: http://localhost:8000/health

The web interface provides:

• Interactive gameplay: Control the agent through a web UI
• Real-time visualization: See what the agent sees
• API explorer: Test all endpoints with OpenAPI/Swagger
• Environment info: View available actions, scenarios, and configuration

Note: When ENABLE_WEB_INTERFACE=false, only the core API endpoints are available (no /web interface).

Building the Docker Image

The Doom environment Docker image can be built in standalone mode using only public base images. This makes it suitable for CI/CD, GitHub, and HuggingFace deployments.

# Build from project root
docker build -t doom-env:latest -f src/envs/doom_env/server/Dockerfile src/envs/doom_env

# Or build from the doom_env directory
cd src/envs/doom_env
docker build -t doom-env:latest -f server/Dockerfile .

What gets installed:

The Dockerfile uses the pyproject.toml to install all dependencies:

• OpenEnv core: Installed as a dependency
• Core packages: FastAPI, Uvicorn, Pydantic, Requests (from pyproject.toml)
• ViZDoom: Installed with all system dependencies (SDL2, Boost, OpenGL, etc.)
• NumPy: For array operations
• Web interface support: Enabled by default via ENABLE_WEB_INTERFACE=true

Build details:

• Base image: python:3.11-slim (public)
• Installation: Uses pip install -e with pyproject.toml
• System deps: ViZDoom build tools and runtime libraries
• Size: ~1.5-2GB (includes ViZDoom system dependencies)

Scenarios Gallery

ViZDoom comes with multiple built-in scenarios for different research tasks:

Basic Scenario

Simple environment for learning basic movement and shooting mechanics.

Agent learning to navigate and shoot in the basic scenario

Deadly Corridor

Navigate through a corridor while avoiding or eliminating monsters.

Agent navigating the deadly corridor

Defend the Center

Stay alive as long as possible while defending the center position.

Agent defending the center against waves of enemies

Health Gathering

Collect health packs scattered around the environment to survive.

Agent collecting health packs for survival

Note: To generate these GIFs yourself, run:

cd src/envs/doom_env
pip install numpy imageio vizdoom
python generate_gifs.py

Environment Details

Action Space

Actions can be specified in two ways:

1. Discrete Actions (recommended for most use cases):

   DoomAction(action_id=2)  # Single integer action
   

   Available discrete actions (depends on scenario):

   • 0: No-op (do nothing)
   • 1-N: Various single button presses (move left, right, shoot, etc.)

2. Button Combinations:

   DoomAction(buttons=[1, 0, 1, 0])  # Press specific buttons
   

   Each element is 0 (not pressed) or 1 (pressed).

Observation Space

DoomObservation contains:

• screen_buffer (List[int]): Flattened screen pixels
  • RGB: Shape [height, width, 3] before flattening
  • Grayscale: Shape [height, width] before flattening
• screen_shape (List[int]): Original shape of the screen
• game_variables (List[float]): Health, ammo, kills, etc.
• available_actions (List[int]): Valid action IDs
• episode_finished (bool): Whether episode has ended
• reward (float): Reward from last action
• done (bool): Same as episode_finished
• metadata (dict): Additional info (scenario name, available buttons)

Scenarios

ViZDoom comes with several built-in scenarios:

• basic: Simple scenario to learn basic movement and shooting
• deadly_corridor: Navigate a corridor while avoiding/killing monsters
• defend_the_center: Stay alive as long as possible in the center
• defend_the_line: Defend a line against incoming monsters
• health_gathering: Collect health packs to survive
• my_way_home: Navigate to a specific location
• predict_position: Predict where an object will be
• take_cover: Learn to take cover from enemy fire

Advanced Usage

Custom Configuration

You can customize the environment when creating the server:

from doom_env.server.doom_env_environment import DoomEnvironment

# Create with custom settings
env = DoomEnvironment(
    scenario="deadly_corridor",
    screen_resolution="RES_320X240",  # Higher resolution
    screen_format="GRAY8",             # Grayscale instead of RGB
    window_visible=True,               # Show game window
    use_discrete_actions=True          # Use discrete action space
)

Connecting to an Existing Server

If you already have a Doom environment server running:

from doom_env import DoomEnv

# Connect to existing server
doom_env = DoomEnv(base_url="http://localhost:8000")

# Use as normal
result = doom_env.reset()
result = doom_env.step(DoomAction(action_id=1))

Note: When connecting to an existing server, doom_env.close() will NOT stop the server.

Processing Visual Observations

The screen buffer is flattened for JSON serialization. To use it:

import numpy as np

result = doom_env.reset()
obs = result.observation

# Reshape to original dimensions
screen = np.array(obs.screen_buffer).reshape(obs.screen_shape)

# screen is now a numpy array with shape [height, width, channels]
# You can visualize it, pass to a neural network, etc.

Rendering

The Doom environment supports multiple rendering options depending on your use case:

Option 1: Web Interface (Recommended for Docker)

The easiest way to visualize the game when using Docker:

# Start the container with web interface
docker run -p 8000:8000 doom-env:latest

# Open in your browser:
# http://localhost:8000/web

Advantages:

• No local dependencies needed
• Works in browser
• Interactive controls
• Real-time visualization

Option 2: Client-Side Rendering (Docker Mode)

Render on your local machine using the screen buffer from Docker:

from doom_env import DoomAction, DoomEnv

env = DoomEnv.from_docker_image("doom-env:latest")
result = env.reset()

for _ in range(100):
    result = env.step(DoomAction(action_id=1))
    env.render()  # Display using cv2 or matplotlib

env.close()

Requirements: Install rendering library on your local machine (not in Docker):

pip install opencv-python
# or
pip install matplotlib

Note: This downloads the screen buffer from Docker via HTTP and renders it locally. Works well but has some network overhead.

Option 3: Local Mode with Native Window (Best Performance)

For the fastest rendering, run locally with ViZDoom's native window:

from envs.doom_env.server.doom_env_environment import DoomEnvironment
from envs.doom_env.models import DoomAction

# Native ViZDoom window (most efficient)
env = DoomEnvironment(
    scenario="basic",
    window_visible=True,  # Enable native SDL2 window
)

obs = env.reset()
for _ in range(100):
    obs = env.step(DoomAction(action_id=1))
    # No render() call needed - native window updates automatically

env.close()

Advantages:

• Native SDL2 rendering (fastest)
• No network overhead
• Smooth real-time gameplay

Rendering Dependencies

Install optional rendering dependencies:

# Using pip
pip install -e ".[rendering]"

# Or install individually
pip install opencv-python  # Preferred for rendering
# or
pip install matplotlib     # Fallback option

Render Modes

Both environments support two render modes:

• mode="human" (default): Display in a window
• mode="rgb_array": Return numpy array for custom processing

# Get frame as numpy array
frame = env.render(mode="rgb_array")
print(frame.shape)  # e.g., (240, 320, 3)

Development & Testing

Local Development

Install dependencies and run locally without Docker:

# Install the environment in development mode
cd src/envs/doom_env
uv pip install -e .

# Or using pip
pip install -e .

# Run the server locally
uv run server --host 0.0.0.0 --port 8000

# Or using uvicorn directly
uvicorn server.app:app --reload

Testing

Test the environment logic directly:

# From the doom_env directory
python3 -c "
from server.doom_env_environment import DoomEnvironment
from models import DoomAction

env = DoomEnvironment(scenario='basic')
obs = env.reset()
print(f'Initial observation shape: {obs.screen_shape}')

for i in range(10):
    obs = env.step(DoomAction(action_id=1))
    print(f'Step {i}: reward={obs.reward}, done={obs.done}')
"

Running the Example Script

The example.py script demonstrates both Docker and local usage with rendering:

# Run with Docker (no rendering)
python example.py

# Run with Docker and rendering
python example.py --render

# Run locally without Docker
python example.py --local

# Run locally with rendering (uses native ViZDoom window)
python example.py --local --render

# Run for more steps
python example.py --local --render --steps 300

Deploying to Hugging Face Spaces

Deploy your Doom environment to Hugging Face Spaces:

# From the doom_env directory
openenv push

# Or specify options
openenv push --repo-id my-org/doom-env --private

The openenv push command will:

1. Validate the environment setup
2. Prepare for Hugging Face Docker space
3. Upload to Hugging Face

After deployment, your space will include:

• Web Interface at /web - Interactive UI
• API Documentation at /docs - OpenAPI/Swagger
• Health Check at /health - Monitoring

Project Structure

doom_env/
├── .dockerignore         # Docker build exclusions
├── __init__.py            # Module exports (DoomAction, DoomObservation, DoomEnv)
├── README.md              # This file
├── GIF_GENERATION.md      # Guide for generating scenario GIFs
├── openenv.yaml           # OpenEnv manifest
├── pyproject.toml         # Dependencies (vizdoom, numpy, etc.)
├── uv.lock                # Locked dependencies
├── client.py              # DoomEnv HTTP client
├── models.py              # DoomAction and DoomObservation dataclasses
├── example.py             # Example usage script
├── generate_gifs.py       # Script to generate GIFs of scenarios
├── assets/                # Directory for generated GIFs
│   ├── .gitkeep
│   └── README.md          # Assets directory documentation
└── server/
    ├── __init__.py        # Server module exports
    ├── doom_env_environment.py  # Core ViZDoom wrapper
    ├── app.py             # FastAPI application
    ├── requirements.txt   # Python dependencies for Docker
    └── Dockerfile         # Container with ViZDoom dependencies

Dependencies

• ViZDoom: Doom-based AI research platform
• NumPy: Array operations for screen buffers
• OpenEnv Core: Base framework
• FastAPI/Uvicorn: HTTP server
• System libraries: SDL2, Boost, OpenGL, etc. (handled in Dockerfile)

All dependencies are defined in pyproject.toml and automatically installed during Docker build.

Configuration

Environment Variables

The Docker container supports several environment variables for configuration:

Web Interface:

• ENABLE_WEB_INTERFACE (default: true) - Enable/disable the web UI at /web

Doom Environment:

• DOOM_SCENARIO (default: basic) - Which scenario to load
• DOOM_SCREEN_RESOLUTION (default: RES_160X120) - Screen resolution
• DOOM_SCREEN_FORMAT (default: RGB24) - Screen format (RGB24, GRAY8, etc.)
• DOOM_WINDOW_VISIBLE (default: false) - Show native ViZDoom window

Example:

docker run -p 8000:8000 \
  -e ENABLE_WEB_INTERFACE=true \
  -e DOOM_SCENARIO=deadly_corridor \
  -e DOOM_SCREEN_RESOLUTION=RES_320X240 \
  doom-env:latest

Troubleshooting

ViZDoom Installation Issues

If you encounter issues installing ViZDoom:

# Make sure you have system dependencies (Ubuntu/Debian)
sudo apt-get install cmake libboost-all-dev libsdl2-dev libfreetype6-dev

# Then install ViZDoom
pip install vizdoom

Docker Build Issues

If Docker build fails with ViZDoom dependencies:

• Ensure you have sufficient disk space
• Check that the base image is accessible
• Verify system dependencies in Dockerfile

Runtime Errors

• "Could not load scenario": Check scenario name or path
• "Invalid action_id": Ensure action_id is within valid range
• Screen buffer issues: Verify screen format and resolution settings

References

• ViZDoom Documentation
• ViZDoom GitHub
• OpenEnv Documentation

License

BSD 3-Clause License (see LICENSE file in repository root)