Game of Life – v1.0

-
My class on Artificial Intelligence's first assignment was to recreate Conway's Game of Life. In his game, a grid of cells continuously evolves over the course of time. 

 First Task: The Interface

GUI for my Game of Life
I wanted to create the GUI first since it would help me visualize the rest of the project. Because graphics in java are troublesome, I used a free online library from Princeton called StdDraw. Using the library, I started with a basic grid and an internal boolean[] to accompany it. Combining the two, I created my first GameScreen: a 400x400 pixel canvas with a black background and grey squares (representing cells). This eventually morphed into the final layout, which, at the time of publishing, is 1600x840. The extra 40 pixels at the bottom are used for buttons.

The yellow cells you see on the grid is the "default" life pattern.


Next: Interaction

Although interaction was already a requirement of the assignment, I decided to add an extra element in the beginning. By starting off with text output, I was able to give the user instructions, and at the same time, ask for the user's input. The input decides the height/width of the grid, and the refresh rate (in milliseconds). Then, the basic rules of my version of the game are shown:


After the grid opens, I wanted the user to be able to click individual cells in order to create a starting life pattern. I created a loop, and using StdDraw's handy methods, I was able to get the location of the mouse when it is clicked. Then, if the mouse's location is in a cell, the cell switches its state (alive/dead). If the mouse is on the play button, then the game starts.

Finally: Algorithms

Game of Life rules aren't super complicated, so designing the algorithms for this game was pretty simple. For every iteration, a cell stays in its current state, unless:

  1. A dead cell has exactly three neighbors, then it becomes alive (reproduction).
  2. A live cell has one or fewer neighbors, then it dies (underpopulation).
  3. A live cell has more than three neighbors, then it dies (overpopulation).
I originally ran into some errors since I was including the cell itself when counting the number of neighbors, but eventually, I debugged enough that I figured out what was going on. After that, simply refreshing the screen for every iteration allows the game to continue.

Download

(coming soon)

Comments

Post a Comment

Popular updates

Half Moon Project Part 2 - More Accuracy

-
Image
This time around, we used the Neuroph library to create a neural network  that can divide the double half-moons more accurately. Neural Networks A Neural Network is a combination of Neurons that feed into each other. Using some really complex math, they can weight each input (from a previous Neuron) differently. Then, after training, they can use backpropagation to calculate which weights should be edited. What this looks like can be seen below. More Accuracy for Half-Moons Since, previously, we were only using one neuron to calculate the line to separate the two moons, we could only draw a linear line. This time, with a more complex neural network, it can separate the two with a function that's super complicated. Theoretically, a human could also derive the equation, but it's so complex that at this point, it's easier to get the Neural Network to do it for us.
Read more

NumberVision – Machine Learning Application

-
Image
The next way we used our Neuron class was to classify digits. Using a UI, our program was assigned to take an input digit (a 5x7 grid, each box has a shade of grey between black and white) and classify the digit as a number between 0 and 9. A Smarter Neuron Graphical depiction of a Neuron receiving more than 2 inputs. Previously, I had only been using a Neuron with two inputs: an X and Y coordinate. Previously, this allowed me to plot my points on a plane like I did with the Half Moon project. However, due to the 5x7 grid of inputs I was getting, I had to alter my Neuron class to be able to take in 35 inputs. Mostly, this involved changing a few numbers.  Applying the Neuron to NumberVision The digit '1', with progressively more noise added from left to right. Good algorithms should be able to generate a result even if the input is a little distorted. I applied the same goal to NumberVision. The flow chart above shows various levels of added distortio
Read more

Machine Learning & Half Moon Project

-
Image
This was our first Machine Learning assignment. Machine Learning is something that I was (and still am) super excited about. Basically, the algorithm 'learns' something, and can then apply it in other situations. Learning & Neurons This was the toughest concept to learn (ha). We started with a Neuron, similar to the neurons in our brains. The neuron can trigger (yes/no) based on a series of inputs, in our case two inputs. The equation for whether or not the neuron triggers is SUMMATION(Weight(n) * Input(n)) > threshold . Each input is weighted differently, and the weights are what we can change to 'train' the neuron. We use this equation:  ΔWeight = learningSpeed * (target - output) * input . For example, if we start with a speed of 0.2, an input of 1, a weight of 0.5, and a target of 0, the weight would change by -0.2 (0.2 * (1 - 0) * 1). Now, with a weight of 0.3, repeat the process. Once each input returns the desired output, the best weights have been fo
Read more