Rekindling love for my first game project as a source of motivation

Where it all began. The original release in 2011.

It’s not a secret that Legacy, my second game project, has been in development hell. I first announced my intention to create it in 2013. Since then I’ve been preoccupied with classes, work and life in general.

Every once in awhile I’d dive in, but I would quickly get bummed out and leave the project in limbo. During one of those “dive-in” sprees I found myself spending a lot of time on MakegamesSA. Thanks to the community over there I soon realized that I had spent most of my time creating a game engine and not an actual game.

Legacy as it stands today. Tech is complete. Mechanics, not so much.

I didn’t have a problem with this in itself as I am a Software Engineer by profession. This exercise really helped me become a better designer, coder, and optimizer in general. However, this made me realize that Legacy “the game” was still a ways off. One could argue that I had barely even began.

Back to the drawing board

I needed to find a way to get this personal project back on track. In order to do that I needed to get my mind off things and figure out why I wanted to make a sequel in the first place.

I spent the next few months learning about game-play. I also spent a lot of time playing what I consider to be great games. Through titles like Final Fantasy XV, Dark Souls, Bloodborne, The Phantom Pain and Breath of the Wild I started to get a clearer of understanding of what I personally enjoyed in games. This helped me identify the kind of experiences that what I would like to give to others.

I’ve come to the conclusion that great games are all about experiences. Whether being “engaging”, “touching” or “challenging” it all boils down to how a game makes you feel. The same is true for bad games as well, with negative emotions like “confusion”, “boredom” and “frustration”.

Remember how you felt when this happened?

Or when this happened?

Trip down memory lane

Building up on the theme of emotion I decided to dig up my original title, The SCND Genesis: Legends. I wanted to see what kind of experience I got off playing it after all these years. Strangely enough, it felt fairly good. As a matter of fact I’d say it’s aged quite well, especially considering the environment it was created in. By returning to Legends, I came to realize that:

• Its game-play was very simplistic.
• Yet I think it was genuinely fun to play.
• Its main menu was surprisingly slick, first impressions amirite?
• The story mode was an incoherent mess
• Audio was buggy, LoFi and didn't gel with the overall theme of the game
• LAN multiplayer was cool (when it worked)
• The code base was abysmal, I’m amazed it even worked.
• The code was really bad guys.
• The graphics were crisp and sharp

Nostalgia overload

Diving in

As a distraction, and honestly as a means to rekindle my interest in game development in general, I decided to clean-up the application. To create an “Enhanced Edition” if you will. I had a few main goals:

• Remember why I started making games in the first place
• Leave underlying game-play mechanics as is.
• To refine the games story mode(better exposition and dialog)
• To make LAN and online game-play actually work
• To make the game less buggy in general
• To switch audio subsystem to Open AL allow for actual volume control
• Switch to music composed by Scotty Zepplin, a much better fit than The Battle for Wesnoth OST
• Use my own library JDS for storing profile and settings data.
• Cleaning up a bit of artwork that hasn't aged well.
• Update the source code of the Game/Engine to be of real use to the public domain

Did I do this?

It took me just over two months to update the code, with all the refinements being done after work or during weekends. The code was really, REALLY, bad. That’s an understatement, it was legitimately TERRIBLE. The list of offenses include:

• Declaring 90% of methods and properties as static (I kid you not)
• Almost zero adherence to Object Oriented/SOLID coding principles
• Using integers instead of enumerations(not even constant)
• Using chars instead of enumerations(again, not even constant)
• Using Strings instead of enumerations (constant, but still bad practice)
• Spaghetti code, everything was everywhere seemingly for the hell of it
• Terrible naming convention( an instance of Achievent.java called “me”, methods called “doThis()”. Really? )
• Having a ton of unnecessary threads simply because I didn’t understand the concept of a game loop.

I know, I know. How was this even possible? I’ve compiled a nice set of excuses:

• It was 2011
• I was 19
• I had just started to learn Java
• I couldn’t get the required feedback when it was so clearly needed. No one was available locally (Zambia)
• I didn’t have steady access to internet
• I didn’t share this code with any of my friends for feedback
• Even if I did they weren’t programmers so it wouldn’t be of much use anyway
• That said, they did help me with some game-play mechanics

Rolling up my sleeves

In order to make sense of the project I had to address its biggest problem, abuse of the static keyword. The application was calling static methods and static properties from all over the place. It was quite overwhelming at first. I was questioning if fixing this was even possible. I had to map out a strategy:

• Make all classes that render to the screen abstract
• Make the properties of those classes “protected”
• Move rendering code to a new “RenderX” subclass that can be instantiated
• Create public getters and setters in this subclass if necessary
• Enforcing singleton design by creating a static getInstance() method in the RenderX class. This was a quick workaround to the current implementation
• Create interface with standard rendering and input methods i.e keyPress, mouseMoved etc
• Extend the interface and update implementing classes as need be
• Port draw calls to JavaFX Canvas and GraphisConfiguration
• Rewrite, draw, scan and implement new content in story mode

Appreciating the results

Miraculously it worked. It wasn’t easy but it worked. I was able to get everything working like for like with significantly cleaner code. You can grab the source code on Github. If you go through the code now you won’t get lost in a labyrinth of doom. It’s still not “the best” but Id say its a good reference point for beginners.

SG: Legends RMX (Quite a mouthful)

Same old mechanics, brand new engine

Network game-play actually works this time

Still happy with the way I integrated Achievements

Lessons learned

What else did I learn from this exercise, more importantly how do I apply this to Legacy?

On the design side I learned:

• Great game-play is King
• Overall presentation must be engaging and refined
• I’ll need tons of focus testing sessions
• I need to make sure that the story campaign is good and flows naturally
• I’ll need to dish out cash for an original soundtrack and probably a sound engineer

On the technical side I learned:

• Good program/engine design is king
• Embrace Object Oriented and SOLID principles as much as possible
• Refactor early and often. Accumulating bad code wont do you any favors

Reflecting on it all

Revisiting my old title, playing it again, reviewing its code and refining it further brought back some much needed fire in my heart. I’m now convinced that I can make Legacy the sequel it needs to be.

Overall, this was a worthwhile exercise. If you ever suffer from any kind of creative block then I encourage you to take a look at your old projects. Seeing what got you started in the first place will not only motivate you but also give you the confidence to power through and continue with whatever comes next.

You can grab the game on Itch.io

The games source code is available on GitHub

You will need Java 8 Update 40 or above to run it, it is available here

Update

My first upload was incomplete, because that’s how I roll >_>. If you downloaded that version get my 8MB patch from the games Itch.io page. The filename is “Missing dependencies for original upload”