ℭ𝔬𝔫𝔴𝔞𝔶’𝔰 𝔊𝔞𝔪𝔢 𝔬𝔣 𝔏𝔦𝔣𝔢 𝔉𝔢𝔞𝔱𝔲𝔯𝔢𝔰

Your program displays a 2D grid of square cells representing the state of the game. Dead and alive should be coloured differently from each other.
Before the game is played a user can use their mouse to toggle cells between alive and dead states.
Once the seed generation has been set by the user, a button can be used to “play” the game. Once the game is being played generation of cells is displayed to the screen a framerate in the 1 to 4 FPS range.
Each new generation is created by code that properly implements the Game of Life rules listed in the “Rules of Life” section above.
Your game of life code can properly handle all of the “Still lifes”, “Oscillators” and “Spaceships” shown on the Game of Life Wikipedia entry.
Game play can be paused and resumed at any time using a button or buttons.
Code has been included to prevent crashes or fault behaviour for the cells around the top, right, bottom, and left edges of the game board.
The current generation number is displayed on the screen along with the grid. The seed should be considered generation one and the number of all subsequent generations continue in ascending integer order.

𝔒𝔭𝔱𝔦𝔬𝔫𝔞𝔩 𝔓𝔯𝔬𝔧𝔢𝔠𝔱 𝔉𝔢𝔞𝔱𝔲𝔯𝔢𝔰

Recorded video submitted to YouTube showing that shows your simulation in action along with user interactions. Your video should include a demonstration of at least one still life, one oscillator, and one spaceship pattern in action.
200+ word reflection on the problems and discoveries you made while coding this project, or a detailed development journal kept during the development of this project.
Class Enums were used to encode the alive and dead states of cells.
You’ve coded a way to restart the simulation with a blank grid.
You’ve coded a way to randomly seed the grid with alive and dead cells.
You’ve incorporated the ofxGUI plugin to allow various simulation settings to be tweaked while the simulation is running. (Example: Slider to control the tick rate of the simulation.)
Functionality exists such that the user can also “play” the game by stepping through the simulation one generation at a time by clicking a button.
The user interface includes a way for the user to change the dimension of the board game grid.
When the user is toggling cells to create the seed, they can also “stamp” at least one oscillator and one spaceship patterns onto the board. How you implement this “stamping” is up to you, as long as the user can specify the location on the board where they wish the selected pattern should be placed.

𝕯𝖔𝖈𝖚𝖒𝖊𝖓𝖙𝖆𝖙𝖎𝖔𝖓

[x] Was able to create the 2D grid of square cells using Initialize/Reset and Randomize Grid Button. A Row/Col slider is used to determine the number of rows and columns per grid.
[x] User can use their mouse to toggle cells between alive/dead cell states.

User can play the generation either through

[x] Auto-Play button
[x] Spacebar key (one generation per key pressed and long press will generate auto-play as long as key is pressed)
[x] Rules of the Game of Life is followed:
1. Any live cell with fewer than two live neighbours dies, as if by underpopulation.
2. Any live cell with two or three live neighbours lives on to the next generation.
3. Any live cell with more than three live neighbours dies, as if by overpopulation.
4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
[x] Can handle all patterns
- [x] Still lifes
- [x] Oscillators
- [x] Spaceships
[x] Can pause the generation (untoggle the auto-play button)
[x] Current generation is displayed on the screen along with the grid. The seed should be considered generation one and the number of all subsequent generations continue in ascending integer order.
[x] Video recording submitted
[x] 200+ word reflection submitted
[x] Class Enums were used
[x] Reset the grid using initialize/randomize grid
[x] Randomly seed the grid by clicking the randomize grid button
[x] Tick rate of the simulation can be tweaked during simulation or before/after a simulation using the tick rate slider
[x] User can change the grid using the row/col slider

ℜ𝔢𝔣𝔩𝔢𝔠𝔱𝔦𝔬𝔫

This project was a blast! At first, I was pretty sure what to do when I was starting to code but when I reached the problem with the edges, I was stuck for days and wasn't able to finish it and decided to ignore the edges instead! What I liked most about this project is that I was able to implement my own code with the things I learned from the course. I am still a little bit confused with using classes in C++ so I just stick with what I think was the most comfortable way for me which was structs. I was able to implement class enums at the very start of the project because last time, I was using enums on my space invaders project as well. I was able to differentiate the two (class enums and enums) with this project and I now know the importance of when to use class enums (which is much better for code readability). I also asked for help in stackoverflow as I was having an overloaded function issue with my enum (which was caused because I was trying to call the enum without referencing the struct) and I was able to do it with the help of fellow programmers! As proud as I am with this project, I am also slightly disappointed that I wasn't able to implement my idea on the wrap around code for the edges. My initial idea was to create a code that will check if j-1 || j+1 || i-1 || i + 1, but I wasn't able to make it work in the end and just decided to ignore the edges instead, which you will see if you played my game of life simulation. I don't really mind that the edges are being ignored and it looks fine either way but I know I could do better and I might improve this code in the near winter break!

If I can recall, I was only able to do 15/17 of the features that were required which includes in the following screenshot next to the reflection.

Youtube Video is located here:

https://www.youtube.com/watch?v=SvvejMvChPs

Untitled