Developer Diary

Blogging Again

The Team

The blog is back again! After experiencing Freeplay this weekend and the feeling that we probably shouldn’t let everything we do fall into complete obscurity, we thought it would be best to start doing this again, even if it is infrequently.

Going to this years Freeplay was a great eye opener for us. It left us feeling good to know that what we’ve been talking about this whole time, wasn’t just random thoughts being ranted out. We’re now know we’re at least moving in the right direction. Even if it is relatively slowly.

As for Redefinition Games development, we’ve been busy as usual. Developing ideas and seeing what we can and can’t do.

Earlier this year we put away Alex’s first engine, the Reverence Engine. It was growing too complex in the way that every new thing we implemented fit nicely, but every old thing didn’t.  It got to the point where it wasn’t enjoyable anymore. So Alex decided to have a break, and get away from it for a while and try and have a bit of fun.

So he started working on another engine that wasn’t so rigid in the way things were implemented and was relatively simple to use.

“I wanted to do some fun things I just couldn’t do with what we had, not without loads of work. Basically I took all the good parts of the engine and everything I knew up to that point, and crapped it out into a C style library and made it run on Windows instead of iOS. Suddenly I was having fun again and it eventually lead to a new engine being born. The MNDCRP Engine. Ever since then, it has continued to grow nicely.”

After working with it for a while it’s needs started to expand, so he started to rewrite some of our editors using the same philosophy of just crapping out the ideas (still keeping within the realms of good programming practices), ditching XNA, and started using OpenTK library. We figured why not considering everything else we were doing was in OpenGL. XNA is still great for Game Development, but moving to OpenTK removed some complexity to the whole system by not having to render Line primitives through a shader. It even gives the ability to use the Fixed function pipeline if needed. This in turn let us test and create new components and tools more rapidly then we could before. The editor is only about a month to two months old now and we can happily say, we’re probably going to scrap the old ones too.

We’ve also started prototyping ideas in Unity now as well, which has been great. We’ve actually been spending time focusing on making actual games rather then technology that will be used to help drive our games. Which has been troublesome to say the least. The way things are going, we might be releasing Unity developed games in the future. We’ll be talking more about Unity in later articles, but lets just say if your not using it, your seriously missing out.

It’s been a long year and a half (maybe more) since starting all this madness. A lot of paths taken, hard lessons learnt, desk-to-head bashing moments, and near givings up. All of which have lead us to learning a few things that we consider to be important.

Firstly, no matter what it is your working on, if your not having fun with it, then your not having fun with it. Even if you delude yourself into believing what you are doing is going to be used for something fun. You might find that what your actually doing is stopping yourself from even reaching what it is you really want to do. For me this was the old engine. It became more of a code grind and a feet in over engineering then something enjoyable to make games with.

Listen to your instincts as well. If you continue down a path against your better judgment, then you should be kicking yourself when you do start doing what you were telling yourself to do all that time ago. However if your judgment isn’t that good… ah…

Earlier in starting all this there were some features that we wanted to put into the engine that we knew could make it easier. Essentially it was just a scripting language, but we thought “no no no, that would be blah blah blah and we wouldn’t have the time.” We’ve recently tested and implemented GameMonkey into a test scenario. Lets just say, if we implemented it a lot earlier, the Reverence Engine might have actually worked out and we wouldn’t be doing the MNDCRP or even stuff in Unity.

No matter how much you learn from other peoples experiences, you’re never really going to learn about them until you experience it yourself and realise that, that is where you are and you’re going to need to deal with it one way or another. Designing it right the first time isn’t always the right way to do it, especially when you don’t take in other unknown factors that can sometimes crop up when things begin to change. We often spent quite a bit of time designing a system that would be “ideal” and handling user level circumstances that could potentially happen, which ended up making a, i guess, a dynamic rigid design. It was simple to use but it was jammed packed with complexity. However, the only difference being that we were the only ones that felt stupid, because we was the only one’s really using it. Lesson learnt!

Don’t be afraid to use what everyone else is using. Game developers, especially indies are notorious for the need to develop their own tech (Alex included). From a certain perspective it’s good, you develop a system the is more in your control for a specific circumstance, and it grows with you. It can be more optimal and perform better then the Generic development environments that some engines provide. You also learn a whole lot, stretch your abilities to the ultimate limit and it’s essentially yours, licensing and all. However, is it well and truly necessary? Can you make your game in something like Torque, or Unity or another commercially available engine? I suppose what you should be really asking yourself is do you want to make a game engine, or do you want to develop games? These are actually questions someone has asked us before. Our resolve then was that we thought we could do it. We can, but it’s just going to take loads of fun sucking times.

If you want to make games, then save yourself some pain and look for an engine that is right for you. For us that was starting to use Unity. The amount of data structures that we was writing for our engine started to get to us and we pretty much snapped, “We’re sick of this crap, we just want to make a damn game.” So we sucked it up, and said to ourself “Use Unity. Everyone else and their Mum’s are using it. Why not us!” And we’ve been kicking myself ever since. Not only has Unity made us enjoy ourselves more and actually make games instead of just designing them. It has exposed us to new ways of thinking for developing games. The lesson we’re saying is ask yourself what you really really REALLY want to do, and do it. Don’t be afraid to use something just because everyone else is using. Because in the end, you’re making your own game and doing everything to make it come into existence. It doesn’t matter what your doing it in.

Experiencing is part of the learning process. You may read this, and think I’m never going to be that stupid, “I’ll learn from this stupid peoples mistakes because that’s how awesome good I am”. But we guarantee you that on any one of these things you will make mistakes! It’s not a bad thing, it’s all part of it, because in hindsight you learn more from the experience of it then you do actually reading it. If your still saying to yourself after reading this paragraph “I’m not that stupid.” Be prepared to surprise yourself.

Well that it from us for now. Until next time. Stay productive.

Subscribe to Blog via Email

Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Ko-fi Coffee

Comments for this post are closed.