Code Journey

My Experience So Far

So, if you follow me on social media you may have noticed that I have recently acquired a job! I guess this post is just a little update about how that is working out so far.

Firstly, the job I have is Junior Games Developer. I am still letting that sink in, this is exactly the sort of job I was looking for and helps confirm that games development is fun - period.

Honestly, the first week was kind of scary, but from university career workshops we were told what previous university students went through and it was something similar - so it seems only natural.

I couldn’t be any happier at this place, the first two weeks are already done and time seems to be flying by. The staff members are super friendly and the community is very passionate about what they want - it is truely inspiring having such a dedicated community and team to work with.

For now, I hope I live up to expectations and I will continue to enjoy myself working here.

As for side project updates, I have already done a bit more work in terms of Suzan2D (Entity Editor and most of the Scene Editor), but I have started to leave side project work due to work commitments. I am considering taking my laptop to work and during the bus ride home working on the game engine, or perhaps working on it after work and tea - but I need to be careful not to burn out.

There is a small side project I have in mind for a small Unity game that will hopefully require little development time.

I’ll post more updates soon so stay classy!

Preview

This is an overview of the 2D game engine that I am building up, this shows the editor application running - more specifically the animation editor. As you can see, there are more editors in the works to help the game development process along.

Purpose

The purpose of this application is to allow developers to use this application to give them a quick head start in development using C++, SFML and ImGui, along with Lua scripting capabilities and the ability to read JSON files. With the way the application is designed it mainly supports lua scripting, but should be able to support other scripting languages if the developer wanted to extend the scripting class and provide a factory class.

I started working on this because I was working on a game over Christmas to try and learn more about the components design pattern. This game was set to be a simple 2D platformer using SFML and I was programming my own physics with it, but with the Christmas holidays coming to a close and job hunting under way, I didn’t dedicate as much time as I should have for development on that.

I was always thinking I would pick the game back up again after coursework submission, and working on side projects helped me learn more over the last semester of 4th year - with one team creating their own 2D engine. The lead developer for that team, Charlie Gilles, who taught me more about components and how to properly setup a project and comments to an industry standard essentially. He would provide updates about the engine, it was exciting to hear what features he had implemented, and I started to wonder how I would go about implementing engine features myself. Since I have never properly implemented a game engine before, I was keen to see how I would cope with development and if I was able and willing.

I had a 2D game that I wanted to make using SFML, I wanted to make a 2D game engine for SFML games - so I started work on Suzan2D.

This is also good for a portfolio piece to try and gain some form of understanding for the underlying architecture of game engines. I think there is a lot taken for granted with game engines and I believe keeping in tune with and understanding underlying features is good practice.

Current Features

For the development of this project I have been using C++ in visual studio with SFML, ImGui, LUA, and JSON files. Also, I would like to mention the blog posts on Re:creation which have been a massive influence and guidance for this project so far. I would highly recommend checking them out when you get the chance, the game looks great and I look forward to it’s release!

Tools

• Development Environment: Visual Studio 2015 Community
• Programming Language(s): C++ and LUA.
• Source Control: GitHub and Git & SourceTree
• Task Management: Trello
• 3rd Party Libraries: SFML 2.4.1, ImGui, LuaBridge, and JSON for Modern C++

Core

• SFML and ImGui integration.
• Editor and application separation.

    #define EDITOR 1	// To use the editor interface.
  

    #define EDITOR 0	// To play the game.
  

• Entity-Component system.
• Integrated scripting system (currently using LUA with LuaBridge).

Animation Editor

• Selectable entities.
• Selectable animations.

• Play/Stop animations.
  

• Editing animations.
  

• Adding animations.
  

• Removing animations.
  

Roadmap

The current direction for this project is as follows:

Remaining Work
Here are features which are planned for this 2D game engine, and are subject to change over the course of development:

• Create an entity editor.
• Create a scene editor.
• Create some basic physics.
• Create some openGL shader implementations.

Prototype
For the prototype, this is mainly a testbed application to demonstrate the implemented features and is not the game I will be making with this technology.

• Create 2 levels with the scene editor.
• Source some royality free art for example gameplay.
• Show the character moving through the levels.

Future Development

As for future endeavours for this project, I will consider making more editors for an easier development process, but overall from the original design not much will change. Otherwise, I feel development will keep rolling over constantly, there will need to be a point where I draw a line and say that is that.

I have in mind at least one game I would like to develop with this technology, but there is the possibility of making more games if the ideas are there.

Blog Updates

I will try and keep a fairly regular schedule for updating blog posts, but one of the most enjoyable things about this project is not having the pressure of major development deadlines. This project will be progressing at my own comfortable pace.

Thank you for checking this out, and keep an eye out here for any more updates!

The state machine design pattern is beautifully described by Robert Nystrom with references to game logic in http://gameprogrammingpatterns.com/state.html and I would highly recommend reading through his site, there are many more patterns that are discussed in great detail.

As he mentions during the end of the article, “…they are most know for being used in AI, but they are also common implementations of user input handling, navigating menus…”. In terms of the programming I have done for my projects so far, the main use I have had for the State Machine design pattern is UI navigation, it is so simple and easy to setup a flow of game logic with. All you have to do is inherit from your base State class and extend to the functionality that you want!

In terms of setting up the base state you can have something like:

```
class UIState
{
	public:
		virtual ~UIState(){}
		virtual std::unique_ptr<UIState> HandleTransitions() = 0;
		virtual void OnEnter() = 0;
		virtual void OnExit() = 0;
		virtual void Render() = 0;
		virtual void Update(float& dt) = 0;
};
```

Then for your inheriting states, you can just override the methods:

```
class TitleUIState : public UIState
{
	public:
		TitleUIState(const UIState& current_state);
		~TitleUIState();
		std::unique_ptr<UIState> HandleTransitions() override;
		void OnEnter() override;
		void OnExit() override;
		void Render() override;
		void Update(float& dt) override;
};
```

It’s simple and powerful once you get to grips with it, and if you use it for the right situation. I have also used it for a turn based combat system (a project currently under development). It seems that this design pattern is very good for any sort of logic that has a set flow, if you know that one state should lead to another - this pattern could be a good shout!