Cyclops

Cyclops is an on the rail shooter game built with Unity using the Oculus Rift.  These are screenshot from the ongoing project. The project will focus on advanced effective use of 3D sound, Oculus Rift camera control, a custom rail system, and eye laser effects.

Frail Future

Frail Future is a PC video game centered on a player who volunteered for an odd program. A program to train an Ai on how humans interact. The Ai is named DONA, Dynamic Operating Neural Analyzer, and she watches your every move. DONA tells you to do things, and if you don't follow her commands she will learn how to trick you into doing what she wants.

Code: https://github.com/bnwbnw3/capstone-brittany

Game: https://github.com/bnwbnw3/capstone-brittany/releases

Screenshots from my Blackjack game.

 (Made entirely in my C++ engine)

Capture the Flag

Learning about states and decision trees

To make capture the flag, computer players need to be able to make decision of what to do and when. I learned how to implement a decision tree for my NPC bears, so that they could play capture the flag with each other. Writing out a decision tree on paper was easy; the hard part was implementing it in code. I spent hours trying to make sure that the states were getting updated properly through their decision trees. I ended up changing my decision tree to make the game work.

Now I have a fully functional computer capture the flag game. The game is made with a level editor that I created. I load in Maya obj files to a binary converter first. Then those binary files are used in my level editor to make a map where I can place nodes to path to. Then I load the saved level file out to binary. Finally the binary level file is loaded into my game where the game automatically starts playing.

Each bear has its own "pather", and depending on their state they do different things. Bears can either fetch the flag, randomly search for the next spawn, return to the base, or run after the current flag carrier.  If bears collide, they are reset to their home base. If bears with a flag collide, the bears reset to base and the flag is set to a new random position. If a bear turns the flag into it's base, the flag resets to a new position as well.

You can view the demo of the game on Youtube. Or press play on the video below:

Pictures of the Game Area:

Picture of Flag turn in:

Old Decision Tree:

New Decision Tree:

Learning AI

Currently I'm working on creating Ai/pathing in openGL. The program can load in .obj files, binary files, and level files that hold .obj information and node information. The program has a character (bear) that paths around the map through nodes that were previously place.

 To build the map, a person can click on the current plane/map to place nodes, selected a placed node by re-clicking it, and connect destination nodes to a re-clicked node. This information can be saved out to a level file. When the level file is read back in, the pathing character will randomly path to a node. The user can also click on a node to make the pathing character path to that node. In addition, clicking on empty space makes the pathing character go to the position of the mouse on the map.

This editor also has the ability to display/change how the program works. The user is able to change the speed of the pathing character through a slider. The user can change to view the pathing characters view or see the world view. The user can change to show all connections that exist on the map. The user can choose to view the current path the character is following. In addition, if pathing connections are not shown, the user can select a node to add new destination nodes or add new nodes. (These variables are editable through a debug menu that pops open when the "~" key is hit) The change to a path by adding more nodes or adding new destination nodes can then be saved out. If the nodes are edited the level must be saved and re-loaded to implement the new paths available.

OpenGL Textures

It took a lot of research online and read a couple of OpenGL books to finally render texture in my scene. Looking the back the code was pretty simple to do; it was just difficult figure how all the pieces fit together. I'm really proud of the scene I have created. I've learned with enough perseverance and dedication one can teach themselves anything. I can't wait to learn how to render more things in OpenGL.

OpenGL - Lighting

Game Libraries

I have now finished an application in OpenGl that  shows ambient, diffuse, and specular light on objects. All lighting equations have been run through the fragment shader to show a nice clean look. I learned the linear algebra equations of how to calculate light and used them in this program. The following pictures show different lighting situations.

Scenes with no specular lighting:

Scenes with specular lighting:

Scene with red specular lighting:




Scene with less diffuse light: