Greetings, fellow indie devs!

Because the creator of the “Oni Hunters” / “Minimon” collection, I’ve seen the sport improvement world evolve drastically over the previous decade. From the previous instances the place most of us had in-house engines to the fashionable period the place Unity was the indie king, the instruments have been ever-changing.

This weekend, I undertook the difficult activity of porting my newest sport from Unity to Godot.

Learn on to find the hows, whys, and classes realized!

Why Godot?

Unity has served many people nicely for years. Nevertheless, their latest resolution to retroactively change their phrases of service, particularly after earlier assurances on the contrary, has severely eroded the belief of many builders, together with myself, prompting us to hunt alternate options.

Enter Godot, a rising star with nice C# help. As an entire newcomer to Godot, I used to be curious to see how my Unity expertise would switch over.

The “Magic” Behind The Fast Port

I can virtually hear the collective gasp of builders studying this – porting a full sport to a different engine in a mere weekend?
Particularly contemplating the dimensions of “Oni Hunters“, with its decade-long legacy, an expansive 4GB repository containing an assortment of just about 3000 property (sprites, audio, maps, and so on), paired with upwards of 500 C# scripts. Sounds virtually inconceivable, proper? However, there is a technique to this insanity, a secret recipe that made all of it doable.

The key lies in an engine abstraction layer. Burned prior to now by difficult porting experiences, I used to be adamant about future-proofing “Oni Hunters”. By limiting Unity-specific dependencies to a mere 3 supply recordsdata and a clear scene structure, the groundwork was laid for a seamless porting expertise. This may not be possible for everybody, however for devs who focus in 2D retro video games like me, it is a goldmine of time-saving potential.

Basically, my technique was all about creating my very own API, a protecting layer that sits between my sport and the engine, maintaining my sport logic insulated from the specifics of any engine. To place it merely, it is like crafting a customized interface with tailored to your sport’s wants. Taking the instance of a 2D RPG sport, this API would home easy strategies reminiscent of LoadMap(), CreateActor(), StartBattle(), and so forth.

For the asset aspect of issues, I made my maps engine-agnostic by creating them outdoors of Unity utilizing Tiled. For issues like sprite sheets, I made positive I adopted a particular measurement conference for each one, that made it easy to automate splitting them into particular person frames and animating it.

I’ve seen this method being known as totally different names amongst gamedev circles, from “code-driven improvement”, “scene minimalism” or “runtime scene technology”. The gist of it’s maintaining the Unity scenes principally empty after which drive the vast majority of the sport logic and content material via C# scripts. When you proceed to leverage Unity’s core capabilities, the emphasis barely shifts from the editor. That mentioned, the editor stays essential for real-time inspections and modifications.

Whereas this method calls for an upfront funding in time and planning, the pliability and independence it gives in the long term are invaluable. Irrespective of how deeply an engine embeds its claws into the trade, with the precise abstraction, my sport stays liberated and agile. I perceive it is not an method appropriate for everybody.

Digging Deeper into DIY Options

Now, I can virtually hear the digital gasps and quick counter-questions from a few of you. “What about all the great options Unity provides you?” you’d ask. Positive, let’s discuss it.

Collision detection? On this planet of 2D gaming, the mathematics behind intersecting strains, circles, and rectangles is pretty easy, except your sport requires heavy-duty physics simulation.

Particle programs? In pixelart video games, it’s normal to depend on handcrafted particle results, crafted by artists and seamlessly built-in as animation frames.

Pathfinding? Traditional algorithms like A* will be whipped up in a concise script of nearly 50 strains of C#.

GUI? Relies upon lots on the sport, however many indie video games do not actually have a necessity for a very advanced GUI. Plus for those who already managed to summary sprite drawing from the engine, constructing a primary GUI layer atop that’s possible.

The checklist goes on. Generally options indie builders would possibly view as important “engine choices” can typically be replicated with a pinch of creativity… typically a lot simpler than one would possibly suppose. And for those who be sure that to maintain that code nicely abstracted, you may maintain reusing it on your entire future tasks.

Godot 101: An Indie’s First Steps

For these new to Godot like I used to be, let’s demystify some fundamentals:

• Scenes & Nodes: Consider your Unity scenes crammed with GameObjects. In Godot, it is all about scenes with Nodes, particularly Node2D for 2D video games. It is related sufficient.
• The Most Essential Strategies: _Ready and _Process are Godot’s finest mates for Unity’s Begin and Replace.
• 2D Sprites: Sprite2D class has you coated.

• Dealing with Enter: Simply faucet into the _Input technique.

• Audio: The AudioStreamPlayer is kind of simple to make use of.

My primary troubles have been with procedural audio, which I take advantage of lots, each for music synth playback and likewise randomized monster results. Whereas Unity’s OnAudioFilterRead is near my coronary heart, Godot gives one thing known as AudioStreamGenerator. Although I hit some snags with it initially (extra on this quickly), it is useful for these in search of dynamic audio options.

This checklist is especially based mostly alone wants whereas porting Oni Hunters, your individual wants will range.

Godot is promising, but it surely is not good. My trials with AudioStreamGenerator in 4.1 are testomony to that, I used to be merely not listening to any audio in any respect, which was frustating me lots. Fortunately, that is the place the ability of the open-source group shines. With some sleuthing, I discovered a PR with the repair, constructed my customized Godot model, and voilà! My audio woes have been historical past. For these frightened of constructing from supply: it’s less complicated than you’d suppose. Simply give Godot’s documentation a go, they’ve good documentation that explains all steps mandatory.

Closing Ideas

Is Godot the brand new Unity? Not fairly… but. It has its charms and benefits, like full supply code entry. Nevertheless it additionally has some catching as much as do. For example, Godot’s profiler doesn’t but help C#, which means third-party .NET profiling instruments are a should. However regardless of its quirks, I can safely say Godot is nicely on its solution to being a formidable alternative for indie builders.

Additionally, I did observe some enhancements in efficiency. This may be attributed to Godot using .NET 6, whereas Unity nonetheless makes use of an older model of Mono.

Transitioning from Unity to Godot was an enlightening journey, and I am genuinely excited to see the place Godot’s future leads. Whereas it could not substitute Unity for everybody, it gives an thrilling playground for indie builders prepared to embrace one thing new. This is to extra experimentation and sharing in our vibrant indie group!

Should you’ve resonated with my experiences, or are curious concerning the subsequent chapter of Oni Hunters, I invite you to remain within the loop, comply with me on Twitter. See you there!

This text first appeared on the writer’s Itch.io web page. It has been republished right here with their permission.