ai techniques for game programming source code

If the player is not within that reasonable forward cone, then do not fire at all.

Heading into PyCon, we wanted to put together something to demonstrate some of the excellent Python packages that are available in the machine learning space as well as showing off some of the newly integrated Intel Math Kernel Library (MKL) optimizations in the latest ActivePython release.

That demo became NeuroBlast, a classic arcade space shooter game that features enemies powered by machine learning.

It was a fun way to get folks engaged at our booth and to learn about whats available in the incredible Python ecosystem.

NeuroBlast is a vertically scrolling space shooter where you control a ship that tries to defeat increasing waves of enemies.

Normally, these enemies fly in predefined formations, with predefined firing patterns, and come in waves.

The big difference in NeuroBlast is that the enemies use machine learning to determine what their firing pattern should be.

Under The Hood: TensorFlow, Keras, And Intel MKL To demonstrate what you can do with the tools available, we decided to build a Neural Network to drive the behaviour of the enemies in the game, and we built it using the popular Keras library using the TensorFlow backend.

Plus, by using ActivePython to develop our game, we could leverage the Intel MKL optimizations compiled into the latest release so anything that uses certain core math functionality, eg.

For the game part of things, were using PyGame and generally speaking I was pretty performance conscious with the implementation to ensure that we could run the game at a solid framerate and still have a lot of CPU overhead available to do realtime neural net evaluations and visualization (eg.

Training the Neural Net Our Neural Net is ultimately a very simple one four inputs and a single output neuron.

It will use supervised learning to do binary classification on a simple problem: was each shot a hit or a miss It utilizes the delta between player and enemy position, and player and enemy velocity as the inputs.

The single output neuron will fire if its activation value is 0.5 and will not fire if it is When building the network, I initially had only a single hidden layer with 4 nodes but found that after training it, it was somewhat erratic.

It seemed like it was very sensitive to the training data and would not settle on a particular strategy in any consistent way.

I experimented with a few different configurations, and ultimately settled on the one we used for the demo.

Its quite likely not the optimal setup, and may have more layers than is necessary.

What appealed to me though was that even with a very small amount of training data, and regardless of how you trained it, it would consistently settle into a similar behaviour pattern which made it great for a floor demo where anyone could play or train the game.

The inputs are the four nodes at the top, with the output node (primed to fire here) at the bottom.

The visualization was cobbled together by myself to run inside PyGame natively.

Inspired by this blog post, the visualization here shows connections between nodes as either red or green lines.

Green lines indicate positive weights that will bias the network towards shooting, and red values inhibit shooting.

Thicker lines indicate higher weight values and thus stronger connections.

I had to implement it natively in PyGame because a traditional plotting library like matplotlib was just too slow.

After training, the network consistently seems to converge on the following strategy: If the player is within a reasonable cone of forward vision then fire indiscriminately.

Ai Techniques For Game Programming Source Code