Final Year Project Minor

[InnerTruce]
Genre: 2D Battle Scroller (Beat 'em up classic)
Platform: Android
Language: C#
Made With: Unity 5

PLAY THE GAME
[Google Play Link]

Robust combo system

My final year project.

I decided to work on a genre I've not really touched on, knowing that this would cater for a fresher game making experience.

Going back and forth with my partner, we decided to go on a classic beat 'em up game, with a "soothing" theme touch. With that I went ahead and worked on a game prototype for the project, and the first version of InnerTruce was created (then known as InnerMost).

This is by far one of the biggest projects I've worked on, with intricate back-end systems, battle systems, Google AdMob and leader-board functionalities all implemented. I also tackled some hard to implement systems like the Combo System for the main game, map generating techniques, etc.

Since we needed the game to strongly adhere to a specific theme, our art assets are therefore very important, and royalty-free art does not suffice. We ended up getting an Artist (from our sister course) to work with for this project. It was also the first few times I've worked this closely with an artist, and it was a great first-hand experience.

InnerTruce is about a protagonist stuck in his own dreams, and the only way to escape is to fight his way out. The game itself is a classic beat 'em up game, with the player having to fight his way through multiple dream stages (inception-ish concept) to break out of his nightmare.

I made it a point to make the game look as polished as possible, since we're planning to publish InnerTruce on the Google PlayStore to compete with other industry standard products. The end game looks really good in my opinion, and I was rather satisfied (huge props to our artist here).

We went back and forth several times during the process of making InnerTruce, tweaking many game variables and UI assets before finally arriving at the final version you see right here. I've also worked on a multitude of system algorithms to make sure the game runs as smoothly as possible, and also cater for a dynamic coding practice. The end result is something I feel is a great first game to be published online, and I'm very grateful for this experience. Check out the game yourself right here and give it a shot: InnerTruce

InnerTruce Main Menu

Tutorial Stage

Level Selection Screen 

Survival Mode

Monsters Spawn Randomly, goal is to beat the timer

Play InnerTruce on the Google Play Store to learn more! :]

Top Down Shooter Project

[Top Down Shooter Project]
Genre: 2D Top Down Shooter
Platform: Android / IOS
Language: C#
Made With: Unity 5

AI swarming up to Player

One of the first Unity projects I've worked on.

This project is mainly a gateway for us to explore the inner workings of Unity's Game Engine, and how we can utilise the said engine to produce quality games in a short amount of time.

The focus of this project itself is not really to touch on the gameplay elements, but focusing more on the back-end systems to make the entire game as modular as possible.

Throughout all my past projects, I've always made it a point to make my game systems dynamic and easy to implement, so needless to say, I was rather excited to work on this project.

To start things off, we decided to go with the classic top-down shooter game idea in a 2D environment, keeping the gameplay as simple as possible.

The game idea itself is relatively self-explanatory; kill enemies before they kill you.

To spice things up just a little, we also decided to add some unique elements like for instance, protecting the generators placed across the map before the enemies get their hands on them and destroy them.

With the idea in place, I went off to build on the framework for this project.

With me working with raw OpenGL throughout basically the majority of my programming experience, I'm rather surprised by what a game engine can do for you. A lot of things are settled for me without the need to manually code them out in the case of raw programming, and it basically made everything easier. (E.g. Collision detection)

Because of that, I thought programming with Unity was going to be a breeze... It turned out otherwise.

At the start, programming with Unity was rather hard for me as everything was so alien. Simple tasks was hard to implement and I end up going online to look for answers repeatedly.

I had to create new base projects to test out simple algorithms like Enemy AI Way Points and I'm not going to lie, it was rather tedious.

But after all the constant trying (and failing) and experimenting, I finally got used to the engine, and everything went on full throttle.

I went ahead and did all of the back-end systems for our game, including the Input System (dynamic functions returning true if Input is collided with a desired collider), Combat System (Firing Process, etc.), Achievement System (using Unity's Delegate Event Functions), Map Generators (Endless Map Scrolling, etc.), Unit System (Parent Unit Class for all entities to inherit from), Timer Class, Analog Handling, etc etc.

I cannot be more grateful for this project as it basically allowed me to explore Unity's game engine with such great depth. I've also learned how to manage systems effectively and create a good base framework that is extremely easy for the game designer to implement his levels.

Unity became my new best friend.

Particle System Emission after a bullet has collided and "destroyed".

Enemy will always switch its priority to attacking the player should he come close.

Mini turrets placed across the map to hinder the player's process

Modular achievement system that rewards the player upon completion of an achievement

Mission KYS

[Studio Project 4]
Genre: 2D Top Down Stealth
Platform: PC
Language: C++
Made With: OpenGL

Modular dialogue system; dialogue content pushed and iterated dynamically 

My fourth Studio Project, and by far the toughest OpenGL project I’ve worked on.

The base framework for this project is from my “AI Behavior Demo” project.

Time was very limited and many features needed to be completed. To add on to that, I hated static coding and wanted robust and modular systems for everything. This resulted in a rough situation for the team as I revamped many things from the base framework.

I wanted this project to “feel like a game”, and therefore I decided to focus a lot on the aesthetics of the game this time around.

I also wanted to venture more on this project and thus, more experimenting was done. I experimented with Visual Graphics like Fading and coded my own UI Manager, to make the game more aesthetically appealing.

Dynamic Button classes with aspect ratio coded in was also done, making the UI work for any ratio.

Later on, I decided to add a Loading Bar to the game, but since multi-core programming on OpenGL is a hassle, I tried many other alternatives and stumbled across a way to do it by swapping Glut Buffer Displays.

Despite all the obstacles and time constraints faced, the project was completed on time and I ended up with a more dynamic framework to work with for my future OpenGL projects, and I was very pleased.

All my efforts on experimenting paid off as I learned many things I wouldn’t have without this project, and I can now code more visually appealing games in the future with this framework.

Now about the game. This is a stealth game where the player has to avoid the enemies and diffuse bombs. New AI techniques was also implemented this time round and a help system was made to aid the player.

To diffuse a bomb, the player has to complete a Mini Game, and when all 4 bombs are diffused, the player wins.

The player loses when the enemy kills the player by shooting at him. Relax, the enemy will only shoot at you if you get spotted.

The player has no way to attack the enemy and can only dodge their bullets once under attack. Going out of range of the enemy’s viewing frustum will stop the attack.

Main Menu Screen with Dynamic Buttons scaled with Aspect Ratio of the screen

Fading systems that fade sprites and speech in / out

Actual loading of the game by swapping glut buffer displays

AI NPC help system to aid the player

Game revolves around player trying to avoid an enemy’s “viewing frustum”

Enemy AI Algorithms implemented. The above shows the Flocking AI Behavior

FIFA World Cup Gallery Display

[Studio Project 2]
Genre: 3D Open World
Platform: PC
Language: C++
Made With: OpenGL

Fire Particle System with 3D Models loaded

My second Studio Project.

The main aim of this project is to fully utilise OpenGL and its graphics pipeline, by showcasing a 3D world revolving a “FIFA World Cup” theme.

I decided to generate a 3D world with galleries showcasing items related to FIFA.

I wasn’t very confident with my skills with the 3D side of OpenGL when I started this project, but I’m very glad and proud of the fact that I was able to pull through with this at the end of the day.

I consider this project to be my “breakthrough” project, since I have learnt alot via constant researching.

For example, a simple stairs collision detection was hard for me since gravity was one thing that I was unfamiliar with. The jerking stairs movement was also something I had took some time to figure out.

Lighting and Normals were another problem I had since a lot of my models were looking very unnatural with the lighting in the scene. I had to replace multiple light sources across the gallery to achieve a more natural look. Small lights were also placed throughout the environment to prevent the entire gallery to be pitch dark upon turning off the lights (via the Menu).

The models were also really big in size and I had to think of algorithms to not render them when the player is out of range (E.g. Do not render models in level 2 when player is at level 1, vice versa). I also had to re-scale alot of Models in Maya just to prevent the lag problem.

All in all, I learned alot via this project, and all the trouble was worth the hassle.

Lighting, particle system, stairs movement algorithm, alpha blending, 3D Model Loading, TGA Texture Loading, Maya 3D Texturing, Animations (both 3D and 2D) and UI Managing are a few examples of things I’ve learned via this project.

Another factor that contributed to the outcome of this project is simply my course mates. Studio Project 2 was a very competitive time for all of us, and we were all trying to out do each other. Naturally, I'd go out of my ways to better myself too. So here it is guys, a lil credits for y'all :]

Main Menu Screen

First look of 3D Environment upon entry

Stairs Movement Algorithm

Displaying an animated GIF using OpenGL

Level 2 of the Gallery with full view of Models

View of Level 1 from second level

In-game menu screen, Lighting has been turned Off

Level 1 with lighting off

AI Behavior Demo

[AI Behavior Demo]
Genre: 2D Top Down
Platform: PC
Language: C++
Made With: OpenGL

Following Algorithm that allows the Collaborative AI to move behind the target

A project to demonstrate Artificial Intelligence and Collaborative AI.

This is a demo, so its COMPLETELY hands-free.

I’ve spent a good portion of my time on this project, since I’ve implemented alot of background game systems instead of only focusing on the AI.

Excel sheet map loading, Map Scrolling, Map generating, Sprite Animation Manager, Map Collision Detection, Render Engine, IrrKlang Sound Engine are some of the back-end stuff that I’ve implemented in this project.

Despite the initial aim of this project being only to demonstrate an AI Algorithm, I do not regret working on the back-end systems for the entire project as I end up using this as a base framework for most of my future OpenGL games. Needless to say, I’m rather happy with the results.

The AI algorithms themselves are also not easy to implement. Taking the following algorithm for example, I had to know which direction the player is facing and allow the collaborative AI to follow behind in one movement behind the player.

Collaborative patterns was also difficult for the most part since I wanted more than static conditions for the collaborative unit to respond to. In order to do this, I made 3 Finite State Machines to work together to allow the Collaborative partner to be more "intelligent".

Now onto the demo itself. The demo starts by “Player” AI (not controlled by user) following way points and a secondary collaborative AI partner closely behind him.

50 / 50 chance of Player AI winning vs Opponent AIs winning.

Following Algorithm, Message Board System, Finate State Machines are some examples of AI-related algorithms I’ve implemented and demonstrated.

Attacking from opposing AI and “guarding” from player AI

"Covering" collaborative demonstration

Player AI backs away while collaborative partner AI covers

Healing when AI detects partner is low on HP

3rd Person Techniques

[Prison Escape!]
Genre: 3rd Person Shooter
Platform: PC
Language: C++
Made With: OpenGL

Spatial Partitioning / Level of Detail / 3rd Person Cam Implementation

Of all the 3D OpenGL projects I've worked on, this is the one I spent most of my brain juices on.

By the end of this project I was about to crumble at the face of the amount of sleepless nights + hair pulling hours, and to be very honest I am still surprised by the fact that I pulled through alive. Hooray for hardcore programming?

All that being said though... I can't deny the fact that at the end of the day, the final product was a feat worth being proud of.

The aim of this project is for us to come up with algorithms to cater for a 3rd person shooter game. I've to basically research online for formulas to the 3rd person camera (this is the one that took me a lifetime to figure out), on top of what had been given to me by my lecturer.

What I initially thought to be as simple as "positioning the camera behind the camera and following him" ended up being one of the hardest algorithm I had to figure out.

The rotation of the camera, how it reacts if the user scrolls infront of the player, what it does when it goes behind a wall, etc. have to all be taken into consideration to make the whole game feel "right".

After what seemed like an eternity, I finally got the 3rd person camera to function. The camera will even reside and "move up" when it hit against a wall, and pan downwards when the player jumps. This is something I thought I'd never achieve.

This algorithm was one valued across the entire class since I shared it with everyone, and it saved us from our imminent C's. I did get some help from online sources. Specifically this video from ThinMatrix on youtube: 3rd Person Camera Java OpenGL

It was written in Java and so I had to find the C++ way of doing it on my own. But nonetheless, it was a HUGE help. Thanks ThinMatrix.

By the way, there are 2 parts to this project. Aside from making the base to a 3rd Person Game, we've also got to make sure everything is lag-free using game development techniques (E.g. Spatial Partitioning, Level Of Detail)

The first technique we tackled is frustum culling, and I had to think of a game idea that utilises frustum culling techniques.

The implementation of the technique itself wasn't really that tough, since the formulas are all provided. The hard part was figuring what to do with it.

After some long consideration I finally decided on a game idea that utilises the frustum culling technique.

The idea goes like this: The player is a criminal escaping from prison, and there are yellow "head lights" above lighting down on the game environment. The yellow lights are of course, the frustums.

The player has to try and avoid being caught in these said lights, and kill off the "enemies", which are the patrolling police officers. The concept was unique and I actually like it alot.

So I moved on to my other techniques. I ended up implementing the spatial partitioning algorithm, level of detail, LUA scripting, and basically everything required, then moved on to do additional features.

Looking back, this one project taught me so much, mainly to just press on and not give up. I guess it was more of a blessing than a nightmare after all.

Thanks Mr Toh :]

Level of detail of objects (Near = Green)

Level of detail of objects (Far = Red)

Level of detail of objects (Very Far = White)

Character in the Light Frustum, under attack from enemy 

Character attacking while in mid air

Jumping, camera pans downwards

Angry Birds

[Physics Simulation Project]
Genre: 2D Side View Puzzle
Platform: PC / Mobile
Language: C++
Made With: OpenGL

Main Menu Screen

A recreation of Angry Birds to simulate game physics.

Main aim of this project is to make use of the popular mobile game series “Angry Birds” to implement simple physics game algorithms.

The art assets are mainly from Rovio and GameFreak, so the credits go there.

This is not a commercial product but more of a personal project to demonstrate physics in an OpenGL game, and this is the project that has taught me how to implement dynamic physics codes for my future projects.

I’ve also done some level design and balancing for this project, going back and forth on a few levels to make sure the game feels right.

Onto the game. There are 3 Types of birds – Regular (Red / Moltres), Split (Blue / Articuno) and Fast (Yellow / Zapdos).

There are also 3 levels, with new obstacles introduced in each level, and new monsters as well. A boss monster will be present in the final level.

Most physics algorithms, those you'd expect in a standard game, are implemented in this demo.

Velocity, Mass, Gravity, Acceleration, Radius Colision Detection, Box Collision Detection (AABB), Force and Rebound Velocity all simulated and implemented.

Level 1, Blue Split Bird, Enemy AI and Gear Obstacle

Bird Splitting Feature

Level 2, Harder Enemy AI, Black Hole Obstacle Introduced

Level 3 Final Level with Boss Enemy AI, and Wood Rebound Obstacle Introduced