Play Free Doom 1
Play Doom On Cmd Download

Twitter: Jak for the Captions! Follow him at @epicjakman Footage: Doom running on a U. Please enable javascript to use this site. The playhuman method sets up a loop that retrieves all user input and forwards it to Vizdoom. To use these new methods and hook up our future AI with the doomtrainer, let’s add a new game.py file and add a play method to it: import.

With recent scientific advancements in Deep Learning, Artificial Intelligence and Neural Networks, as well as steadily evolving tools such as Tensorflow, Pytorch, and Keras, writing, testing and optimizing your own Neural Networks is now easier than ever before. Amazed by the results of the Vizdoom competition, I decided to implement my own simple Doom AI from scratch. Having no practical knowledge of Deep Learning, I decided to share my journey from an empty Python project to an (at least decently) working Doom AI.

Prerequisites

First of all, I want to cover this topic more from an engineering than a Data Science background, so don’t expect any deep elaborations on the theory behind Neural Networks. A great introduction to this topic is the Artificial Intelligence A-Z course on Udemy. If you prefer books, check out the Hands-On Machine Learning with Scikit-Learn and TensorFlow book on Amazon.

TO PLAY DOOM 2, FINAL DOOM OR MASTER LEVELS DEMOS FROM DOS -Quick info (see below for more detailed instructions): In your Doom2 directory, at the DOS Command Prompt, type doom2 -playdemo DemoName (no '.LMP') for regular Doom 2 demos; Or type doom2 -file WadName.wad -playdemo DemoName for Doom 2 demos that require an additional WAD file.

Additionally, feel free to check out the following papers:
– AI handbook
– Reinforcement Learning I: Introduction
– Asynchronous Methods for Deep Reinforcement Learning

Software

To train the Doom agent, we will use the Pytorch library. Since we have to move a lot of data through the Artificial Neural Network (ANN) we are going to create, training on a GPU is mandatory. To set up your PC, check out Tuatinis amazing blog post on setting up an environment for deep learning.
Besides that, you will need Python and the pip package manager as well as Vizdoom to play the game and interact with the ANN. To install Vizdoom, please follow the instructions on their githubpage.

Setting up the project

To run pre-configured scenarios for training an AI, Vizdoom provides a bunch of .cfg files we can use right away. To make use of them, I copied the Vizdoom scenarios directory into an empty Python project. Among these scenarios are some fairly easy (Basic, Deadly Corridor) and some more challenging ones (My way home, Deathmatch). We will try to create a generic model so we can easily switch between all these scenarios.
Next, I created a src directory, that will contain all source code for the project. In there, I split up the project into three further parts: doom, which contains our client for Vizdoom and at the same time provides an interface to be used by our AI. Besides that, I created a models directory, which will contain the different Deep learning models, as well as a utils directory for logging, argument-parsing and preprocessing.
In the src directory itself, we will need an empty __init.py__ and a main.py file as starting point for our project.
If you followed along until this point, you should have a project structure that looks like this:

You can also clone the full repository from doom-ai.

Playing the game

Before we start creating our AI, let’s get used to the Vizdoom API. To do so, we’ll create a simple client that allows us to play the game ourselves! To keep our interface to the Vizdoom API in one place, I created a doom_trainer.py file inside the doom directory:

The create_actions method will later be used to generate all the actions our AI can choose from. To play the game ourselves, we can leave this method empty for now. The DoomTrainer class contains methods to initialize Vizdoom, play as human, create new episodes and to let our AI make actions. I will go into more detail about these methods later. For now, let’s focus on the __init__ and play_human methods:
__init__ takes a params object that contains all information required to train the AI. The first two lines of this method create a new DoomGame instance and load the scenario based on the path from the params object. Then, if we pass the ‘human’ model, we set the game mode to Mode.SPECTATOR, which will hand all control to the game to the player.
The play_human method sets up a loop that retrieves all user input and forwards it to Vizdoom.

Play Free Doom 1

To use these new methods and hook up our future AI with the doom_trainer, let’s add a new game.py file and add a play method to it:

The first two lines will initialize Pytorch to run on our GPU. After that, we check the provided model from the provided parameters and then call the according method. Beside the human model we will implement now, I added a model for A3C. We will look at that later.

With that said, let’s implement the play_human method, so we can finally start interacting with Vizdoom:

That’s all the code we need! We instantiate our new class and call its start_game and play_human methods.

We will call this new method from a new main.py file defined in the root directory of the project:

Here, we simply get the command line parameters via the parse_arguments method and pass them on to the play method we just created. Since we are playing ourselves, we only have to worry about the scenario and model parameter for now. As you can see, I set the model to “human” and the scenario to “deadly_corridor”.
If you run the main.py file, a screen should open with the deadly_corridor scenario loaded. The goal of this scenario is, to reach the green armor at the end of the corridor. Below, you can see one оf my attempts at solving this challenge 🙂

If you want to challenge yourself, go to the scenarios directory and open the deadly_corridor.cfg file. In there, set the doom_skill = 5 for the most deadly enemies!!

Image preprocessing

Before we can start to work on our AI, we have to consider the huge amount of image data we have to process. For each frame, we have to analyze three matrices (one for each RGB color) of the size 320×240 / 640×480 / … depending on the size of the screen. We can divide the amount of data by 3, simply by turning the input image into a gray-scale image. While we will lose some details with this method, I find it a good compromise between performance and effectiveness of the AI.
In addition to that, we can reduce the input size even further by scaling down the input images. For example, we can turn one 320×240 grayscale image into a 160×120 grayscale image and reduce the input size by 50%. Of course, this also results in some loss of data, so we have to carefully evaluate how practical this approach is.
Below you can see the result of applying both of these “optimizations”. First, the colors are combined into one grayscale-image, then the size is reduced by 50%.

Using the imresize function from the scipy.misc package, implementing these transformations is very straightforward. In the utils directory, I created a image_preprocessing.py file that contains a single scale method:

It takes an input screen_buffer, the target width and height and a gray flag as parameters and applies the transformations accordingly.
As you have already seen above, we will use this method in the get_screen method of the DoomTrainer class:

Creating the AI

With that out of the way, it’s time to create our actual AI! There are a lot of different approaches to train an efficient AI using Reinforcement learning. Since it is one of the most recent and effective ones, I decided to start with the A3C algorithm. This utilizes the power of Deep Neural Networks (DNN) by running multiple agents for training at the same time. Each agent t

Play Doom On Cmd