Projects

Majtron - 3D arena shooter

What is it?

(If you just want a quick overview just stick to this section or have a look at the images below)

Most of it is a game engine, starting from low-level OpenGL commands upt to a high-level interface in Common Lisp, along with a 3D Arena shooter demo (cyberpunk/magic inspired game called Majtron).
So, basically just a 3D shooter built from scratch.

Each level in the game has a number of different types of enemies and pickups to help you.
To pass to the next level you need to clear all the enemies.

The movement was meant to be some form of bunny hopping/strafe jumping (a way to gain and maintain extra velocity), inspired by the Quake 3 engine and the Source engine

The twist is that the projectiles you fire are both slow (more like magic orbs) and you can add spin (makes combat more like a fighting game).

The Background

Tihs was my University Final Year Project and the only requirement was to build a game.
I wanted to challenge myself and build not only a 3D game engine but also do it in Common Lisp (a language with minimal libraries geared for game dev despite being highly suitable).

For a final year project (where they prefer that you implement specific algorithms and focus on the report), this was an incredibly dumb idea, but as a tool for learning and increasing my knowledge base, this was probably the best decision.

The Preperation

Problem 1: I didn't know anything about graphics programming or making game engines.
Sure, I had done 2D games in simple engines like pygame, or played around in Unity, but never something this big.

Problem 2: Even if I did know, I couldn't be sure if it was doable within the project time frame (4-5 months alongside other courses)

I solved these first two by doing what I call light research: casual skimming through enough videos and articles (sometimes even flicking through digital books), over a week or two until I could convince myself that I had understood the basics.
This was very much more of a mental solution, but most of the time the problem is motivation.

From here, I started going though the learnopengl.com tutorials along with reading relevant parts of books like the OpenGL Bible or Real Time Rendering.

With programming, you have to actually implement to see if you understant, so (along side the tutorial game I created) I did a demo game in C (trying to replicate one of my old tower defense games on Scratch).

The actual game was going to be in Common lisp not C, so I tried to familiarize myself with the Common Lisp equivalent libraries and syntax I would need to use. Again, This is programming, so I decided to test if it was viable with yet another game, a Tetris clone.
This time I somewhat completed it. This was a little more challenging than I expected because of the overall lack of documenation, but this required me to dig deep into a few of the library source code to try and understand ambiguities

The Idea

By the time University started, I decided to make an arena shooter as this was both a favourite genre of mine and a game that would be in 3D (so would require going deeper into OpenGL and the collison algorithms).
I then decided that I wanted to change a part of the mechanics.

The actual movements, i.e, strafe jumping, bunny hopping, were the main parts that made them so fun, so I decided to change the projectile mechanics (a bias from having a lack of talent in my tracking ability) to make them more interesting.
The aim was to combine the projectile spin mechanics of table tennis, with the movement of Quake 3.

To tackle such a large project in a limited time (around 4-5 months total across 2 terms), I split it into these categories:

Display a 3D object on the screen
Add textures to objects displayed on screen
Automate the rendering process by creating a parser to load obj files on screen
Add ability to move camera to view objects from different angles
Add collision system between camera and 3d objects
Add basic physics including gravity to camera/player
Add quake 3 specific physics
Add lighting system
Add projectiles that can be fired by player
Give the ability to add spin to projectiles
Then for the game I split it into these categories:
Display enemy
Enemy move in world
Make enemy fire projectiles to player
Add different types of enemies
Add different types of levels
Integrate enemy and levels to complement each other
Add different items
Add multiplayer
Add UI system
Make a UI that fits the theme of the game

The Process

(If you really want you can just go to the source code and follow the version history)

looking back a quicker method might have been to look though game design patterns and familiarize myself on how things are supposed to be designed/structured.

However,

A: The process of figuring it myself is more educational and this is an educational setting not a comercial one

B: There was a high likelihood that my underdeveloped programmer brain would overuse them

C: I don't like them

I went about going through each 1-2 tasks every 1-2 weeks, trying to keep the architecture simple and worked out, by refactoring at the end of each feature/couple of features, what was the best and clearest way to structure the architecture.
I found this was the best way to balance keeping the code clean, and, at the same time not overabstracted

A large chunk of time ended up being spent on the collision system (the backbone behind the simple physics engine).

In the end I managed to have a working game and game engine, but given the time constraints the game side wasn't as extensive as planned (lacking a multiplayer and complex ai), however it was a good stepping stone that helped me have an idea of how to design and create any future complex systems.