EAE 6320 Final Project Write Up

About my game:

This project is part of the Game Engineering 2 class taught by professor John-Paul Ownby at the University of Utah.

My game is a simple dodger where you have to defend yourself from an incoming enemy trying to destroy you. You have 3 lives-- try to be smart in using these lives and try to live as long as possible! As it is, the game has no "win condition", and the player disappears and you "lose" when you lose all 3 of your lives and you are required to restart the application. There is a rumble effect that happens every time you lose a life on the controller you are using(currently supports X-Box 360, One and Elite controllers).

The image below shows an example of a projectile(enemy) falling while the player is stationary.

The image below shows the player after he/she has lost all 3 of their lives.

HOW TO PLAY THE GAME:

Player controls a being with which he/she can move in the lateral axis(No vertical movement). 

Controls:

Right stick - Player lateral movement

Left Bumper - Increase Player Speed(reduce challenge/hardness of the game)

Right Bumper -  Decrease Player Speed(increase challenge/hardness of the game)

Underlying logic of the game:

1.  Own System Used - Microsoft's XInput Library for XBox controllers:  This is the API provided by Microsoft which I use to get input from controllers and translate it into functions which the player can use. Fairly easy to use and implement.
2. JP's system used - Graphics Engine: This is used to render all the shapes and models in the game.
3. Luis Garcia Remes's 2D Collision System: Used for detecting and handling collisions between objects. Fairly easy to use.

• Microsoft XInput Library-- Self implemented system:  Very well documented on microsoft's website, and there has been very good resources online to implement this library as a .lib static library in conjunction with all the other graphics libraries. Most of the implemented functions work great so far, there was even provision in the API to have support for multiple controllers.  There was a small bug where the left stick was having trouble detecting input, but it has been fixed! Probably the best and easy to use API I have ever had the pleasure of using.
• 2D Collision System - Luis Garcia Remes: Also a very easy to use interface. Has been optimized very well for circles and rectangles, but works almost perfectly for all the other models I have tried it on. The one problem I had initially was the lack of knowledge that these colliders were centered at (0,0), but once I got them to center they worked perfectly. There was a very nice, simple and intuitive layer for all objects exists, which is a variable you can tweak. If you want two objects to be able to collide, they have to be on the same layer, else they will not. Very simple and easy to understand and use interface.
• https://luis-garcia-remes.itch.io/engine-system-proposal/devlog/111042/engine-sy...

• Using the graphics interface and learning about it was a very good learning experience for me. Having two threads talking to each other to pass back and forth renderable data was incredibly brilliant and helpful. Having the idea of a gameobject with all of its information(effect, geometry) contained in one object was also very helpful.

Lessons Learned:

• Having platform specific code and platform independent code was a concept I was not even aware of until the beginning of this class. Learning those really helped me and rest assured I will use them in all my forthcoming projects.
• Naming conventions and references. Previously, in most of my projects I would use "#include<xxx.h>". It was good to learn and make use of Visual Studio's inbuilt reference system to make the code look a lot cleaner.
• Learning how to build off of an already existing robust codebase was something I heard I would be doing a lot in the industry. It was a good and refreshing experience to do it first-hand.
• Getting a very in-depth experience in human readable files and reference counting for loading and unloading(initialising and cleanup) of assets was another major takeaway. I had not quite understood the depth of the importance of human readable files and how a simple lua file can make interfacing and implementing better code so much easier until I was introduced to it.
• Performance through binary files: I think a very good strategy that our professor John-Paul applied was introducing us to binary "readable" files AFTER introducing us to human readable files. Small things like converting .lua to binary files can make so much difference in load times and size of files, and until this class I had no idea just how much. Pretty mindboggling to see it in action and implement it.
• Multi threading and actually having an application and a render thread and using the concept of buckets to transfer information back and forth is a genius idea and I was glad I could grasp its concept.
• Getting a brief idea of how OpenGL and D3D works and doing very basic shader code was also pretty cool.

The .zip to download the game is below. Thanks for reading!