Watch as your stars live, thrive and die...and all over again.

Game development often thrives on creativity, communication and collaboration, especially during events like game jams. When Stars Collapse began as a submission for the 8th Ludum Dare Discord Jam, where our team of six, including one seasoned developer, transform our ideas into a playable experience within 48 hours. Out of 168 entries, our game ranked 29th, placing us in the top 20%. Inspired by this achievement, I dedicated a week to refining and polishing the project, focusing on clean code and overall game completion.

I’ll detail the game, and my contributions to the project.

The Game

When Stars Collapse plays as an arcade universe survival management game, where you play as the Sun God, tasked with looking over your universe of stars.

Players have to ensure to heal their sick stars before they turn into black holes and suck other stars. Stars are healed by dragging a healing rune to the sick star. A healing rune is created when 3 meteors of the same colour are collected by catching it before it flies away. The game is over when too many black holes have taken over the player's universe.

My Contributions

Post Jam

Although the game was ranked quite highly, the game wasn't fully complete, as it had many bugs and was missing many components that made it a proper game. As a challenge, I decided to refactor the entire codebase from scratch within a week, making a clear hierarchy of code.

I essentially got to experience the full development cycle, starting from a blank Unity Project, to a fleshed out, working system, with proper implementation of code patterns and architecture. This ranged from

• Events System
• State Machine
• Animation states
• Audio Management
• WebGL optimisation.

I additionally diagrammed such systems as a form of documentation for both the team and my blog.

Details of my activity can be seen here:

During the Game Jam

Because of the short time limit, it was essential to have clear work delegation. I was tasked to handle:

1. The Planets class and states

• I needed to instantiate the Planet's INITIAL State in order to make sure that it safely instantiated without any Black Holes sucking it away.

• Animation process of being sucked in by a Black Hole

public void ShrinkUntilDestroy()
{
	StartCoroutine(Shrink());
}

IEnumerator Shrink()
{
	Transform t = gameObject.transform;
	while (t.localScale.x > 0f)
	{
		t.localScale -= new Vector3(0.1f, 0.1f, 0f);
		yield return new WaitForSeconds(0.1f);
	}
	Destroy(gameObject);
}

2. Particle Effects

• Using Unity's Particle System, I was able to update the 2D raw image of each particle.

3. Polished HighScore Scene

• Made a highly custom, highly polished Highscore Screen that displayed all the scores in a digestible way using Unity Coroutines.

4. Crisis Management

With just one hour left before the submission deadline, I discovered that the Wwise Audio System was incompatible with Unity WebGL, preventing the build from completing.

Thinking quickly, I informed the team and suggested to remove sound entirely from the WebGL version, while retaining audio for the Windows build. I calmly delegated the task of building the Windows and Mac versions to the other developers, allowing me to focus on going through each script to eliminate any audio commands.

What I've Learnt

1. Management in a bigger team setting

To see the grander picture and everyone's role in creating the game required me to delegate tasks and see the missing pieces. Not only within developers, but also with the UXUI designers, game designers, and artist.

2. Complete and polished game

The refactoring process gave me greater insight into not only the full development cycle of a game, but also the different disciplines a game involves to create the product it is, and how to achieve each aspect until publishing.

If anything, it has given me greater appreciation for the different specialisations needed to create a great game, and enforced my ideas that a game is a collaborative project that celebrates everyone's role.

3. Code Architecture

The refactoring process also allowed me to develop a game with a strong, clean code architecture utilising code patterns and good practices. This allows the project to be extendable, where I'm able to add and change features easily.

For further information, here are some related posts: