Crumble of Civilizations

Programmer & Designer

Project Information

  • This is a PC game.
  • Team size: 2 students.
  • Duration: 1.5 year. (Ongoing)
  • Tools used: Godot, Unity Engine, GameMaker: Studio, Google Sheets, Pen & paper, Notepad++.
  • Role: Programmer, Designer.

Design with scale in mind

Crumble of Civilizations challenges in a few areas:

  • All systems interact with each other causing more complex behavior to emerge the more systems we add to the game.
  • Our goal of having specialization as a core aspect of the game indirectly causes us to require a lot of content.
  • The game world is extremely large so it is important to keep optimization in mind.
  • The game is multiplayer.

The issues force us to constantly think about the scalability of our newest systems and content. Expensive calls are risky as the player can force systems to make more of them by repeating specific actions meaning that we are always measuring against the worst possible (known) scenario.

In order to speed up our content pipelines I have set up various tools and file structures such as the one shown image.

In order to determine how to best create such a file setup we would often wait until later stages of development to see what the actual pain points of those files are before creating a proper version. Doing it this way avoids wasting a lot of programmer time creating a file that supports all the wrong types of input.

Early attempts

Crumble of civilizations (or CrumbleCiv in short), is a game about scale. The first prototype was built without any design direction at all and used GameMaker: Studio. This tool allowed me to quickly build the basics of the game and enabled me to show it to others. We then formed a team and moved to Unity engine instead, this was due to three separate reasons:

  1. Maintaining a bigger project in GameMaker is almost impossible.
  2. My teammate had no experience with GameMaker.
  3. Working with the Unity engine was a good learning opportunity.

We then set out to create some structured goals for the game. Our core would be the huge world. We wanted to challenge ourselves to have at least a billion tiles in the game. Additionally, we aimed to give the players a lot of agency and ways to interact with the world by enabling them to change all tiles on the map. We also added multiplayer elements in the game so players could play together.

This presented some interesting challenges. I needed to create a system that would properly scale with the game we wanted to build. This led to the design pillar "Everything X100". This pillar was then applied to all future systems such as units, tiles and buildings.

Learning C# & Unity

The first version of the game was build entirely in GameMaker. This really helped with the initial setup as I knew exactly what to do or avoid when working on the foundation of the game.

To start working on the second iteration of the game I first needed to learn C#. I had no prior experience with this language so it took me a while to get to the point were I could create something. After about 1.5 months I got a good gist of what's out there and was able to start doing some basic work on the game.

During development I would iterate the code as I gained more knowledge of C# and Unity.