How to create, handle and kill complexity

While making my game (link to a somewhat unfinished or finished game, depending on when you read this) I've learned some things about complexity and simplicity. I want to make the game big while keeping it small, it should amaze, perplex and entertain the user while at same time have a small core of technology to make it bugfree and possible to understand (and by that possible to develop further). These two goals work against each other, and that's both hard and interesting.

Wanna kill complexity? Remove things. Redesign the whole idea from scratch and make it consist of fewer things. If the only goal is simplicity, just make it simple, it's that easy. At least if you have full control over what you create, otherwise you'll always be limited by someone else's idea of complexity and simplicity.

Can't do that because the idea is already as simple as it can get, you can't remove things because the whole idea is built on being maximalistic and multifaceted? Add order. Maybe it turns out it wasn't that complex but only looked like it was. Order things in the right way and many things can look and feel, and also BE, fewer things. A bunch of random files in a folder can go from an unexplainable mess to an ordered list, from 1000 random things to an ordered list of 5 different kinds of things, with just some sorting and cleaning up. You didn't change the core idea but still turned complexity into simplicity and the number of things from many to few.

Can't do any of that, because the thing just HAS to be complex and impossible to understand? But you still want it to look simple because that would make things easier? Then abstract it away, hide it behind a name and just look at the name instead of at the complex mess it represents. The problem is you will forget what's under the abstraction, which will make it harder to know how to change it if it turns out to be bad. You'll have to live with this fact and assume, and maybe trick yourself, that it's actually good.

Or you could just make it complex. Let it lie there as a complex mess for everyone to be seen. It will be as ugly or beautiful as it is. Every method for simplifying something complex will remove some complexity, and if complexity is your endgoal, maybe just don't touch it.

I've made a very simple core system for my game's physics which is just a small file of Javascript code. I also have 100 different story events that are described in a long list of similarly structured raw code, it's veeery many lines of code but they don't feel as that many because I structure them very thoroughly. I could have made this code much shorter by putting similar code in an abstraction and then just referencing that abstraction with a short name, but I need to be able to look at a story event and immediately understand what happens on a low technical level and an abstraction would hide away this low-level technical description in another place. I also have 1500 lines of dialogue, which are placed in an ordered and numbered list to work properly in the game. Here I've also made a program that translates my bookwriting style to my code style so I can write the dialogues like I write a book and it will magically turn it into code that works perfectly in the game. The problem was that half the time writing the story went into changing numbers in the numbered list, so I needed a way to write the story without having to think about numbers and code. Here I had to hide the underlying technology, with the risk of forgetting how it works and by that create a confusing complexity in my head, because I need to be able to create a rich and complex story in an easy way. And, some things in the game are just random one-time happenings like you fighting a stalking fan with different kind of weapons, that have lots of code with no relation to anything else in the game that just lie there and mess up the order because they can, will and have to. Maybe I could reuse code from a similar minigame to make the code simpler, but maybe that would make the stalker-fan fight into something other than I want it to be.

As you see, there's no definitive way to deal with a project's complexity. In my case, the best way to structure my project seems to be some kind of structured non-structure, or a big mess of differently structured parts pieced together. The same structure everywhere would help some parts but make other parts worse, and on the other hand too many different structures may make the whole project hard to understand. Structure removes mess but it also adds structure, which is an additional thing, and enough additional things in the end becomes a big mess... Do you start to get what's hard with aiming for both complexity and simplicity at the same time now? There's no definitive method to do it, and there's also kind of no definitive goal.

If you're doing a small fun project, just use the user-friendly tools out there and have some worryless fun. But if you want to make something both complex and simple and also plan on making it even complexer and simpler in the future, follow this site because I will probably learn more about this.

Subscribe to Golden emails