I attempted to make the same 2D game prototype in React, Unity, Godot, Construct, Game Maker, and Phaser. Here‘s what I found.

As a tabletop game designer, I often find myself wanting to create digital prototypes of my physical games. A digital version allows me to easily playtest, iterate, and share the game without needing to print out components or get players together in the same room.

For my latest competitive card game design, I knew I needed a game engine or framework that could handle a few key things:

• State management to keep track of game rules, turns, and win conditions
• A clean UI to display the cards and gameboard
• Smooth drag-and-drop functionality to play cards
• Multiplayer architecture so I could test the game with others

With these requirements in mind, I set out to build prototypes in a variety of popular game engines and frameworks to see which would work best for my needs. Here are my experiences with each:

React

As a web developer, React was a natural starting point for me. I love how it handles state management, which is crucial for complex games. However, implementing drag-and-drop proved very challenging. Libraries like React DnD help with basic functionality, but didn‘t provide the precise control I needed over where cards could be played and when.

The boardgame.io framework offers more gaming-specific features on top of React. But learning this in addition to React felt like overkill for my prototype. React is amazing for web UIs, but wasn‘t ideal for this type of interactive game.

Unity

Next I tried the incredibly popular Unity engine. With extensive documentation, tutorials, and a huge asset store, it seemed very promising. I enjoyed coding in C# and was able to implement core functionality without too much trouble by leveraging my object-oriented programming knowledge.

However, I quickly discovered that Unity is much better suited for 3D than 2D games. The editor is powerful but unintuitive, with a steep learning curve. Trying to wrestle Unity‘s 3D pipeline into a 2D perspective felt like more trouble than it was worth for my simple card game.

While I‘d use Unity for a more complex game, especially anything 3D, it was overkill for my prototype. The 2D tools and workflow just aren‘t as refined or streamlined compared to other options.

Godot

Godot is a lesser-known but very capable open source game engine. It supports a variety of programming languages including GDScript (similar to Python), C#, C++, and even visual scripting.

I loved Godot‘s node-based architecture, which felt more intuitive for 2D than Unity‘s system. It has solid built-in 2D features and a cleaner interface than Unity.

Unfortunately, it was quite buggy in my experience, with frequent crashes. The documentation also pales in comparison to Unity‘s, especially if using C#. Most answers are in GDScript, requiring manual translation.

Godot is a promising open source option for 2D games. But the smaller community, lack of tutorials, and instability made it a frustrating choice for my prototype compared to more established engines.

Construct 3

Construct 3 is a drag-and-drop game creation tool aimed at non-programmers. Its event-based visual scripting system makes it easy to build simple 2D games quickly.

I was able to prototype basic card game mechanics very rapidly compared to coding everything from scratch. The editor is straightforward and handles asset management smoothly.

However, Construct‘s ease of use comes with a hefty price tag, as most features are locked behind a monthly subscription. It recently added JavaScript support, but the visual interface is still the primary interaction method.

While Construct is great for small 2D projects and accessible to non-coders, it wasn‘t flexible enough for my needs. I wanted more control over the codebase without paying ongoing fees.

GameMaker Studio 2

GameMaker has been a popular choice for 2D games for years, powering hit indie titles like Undertale and Hyper Light Drifter. It offers both a beginner-friendly drag-and-drop interface and its own scripting language, GML.

I found the editor intuitive and was able to set up the foundations of my card game relatively quickly. The interface feels polished and assets are easy to manage. GML takes some adjusting to, especially coming from other languages, but does the job for this type of project.

However, some aspects of GameMaker, like mouse input detection during drag-and-drop, required extra finesse to get right. It‘s also ultimately a proprietary ecosystem – your time investment learning GML doesn‘t readily translate to skills applicable elsewhere.

GameMaker is a solid choice for 2D games, especially if you‘re just starting out. But for me, the idiosyncrasies of GML and lack of transferable skills made it less appealing than other options.

Phaser

Finally, I tried the Phaser framework – an open source, JavaScript-based solution specifically for 2D web games. It provides helpful abstractions over core HTML5 game development APIs.

Unlike the other options, Phaser is purely code-focused. You‘ll need to be comfortable with modern JavaScript and web development to be productive. It has a steeper learning curve, especially for beginners.

However, I found this to be a major strength for my use case. Leveraging my JavaScript skills, I was able to rapidly prototype my game mechanics with minimal fighting against the framework. The drag-and-drop gameplay felt smooth and the overall architecture was easy to reason about.

Phaser‘s documentation is lacking compared to Unity or GameMaker. You‘ll often find yourself digging through the source code or turning to the community Discord for help. But it‘s very capable under the hood for 2D games.

As a bonus, improving my JavaScript and general programming skills while building my game felt more rewarding than investing in a proprietary ecosystem. Phaser became my engine of choice for this project.

Conclusion

After much experimentation, I settled on building my digital card game prototype with the Phaser framework. While not the flashiest or most beginner-friendly option, its unopinionated JavaScript foundation meshed best with my workflow and skillset.

The drag-and-drop card interactions and turn-based mechanics were straightforward to implement. Leveraging my web development knowledge made extending the game painless. And as an open source framework, I‘m not locked into any subscriptions or restrictive ecosystems.

However, Phaser certainly isn‘t the right choice for everyone or every type of game. If I was building a complex 3D game, I‘d use Unity. For a simple 2D game without coding, Construct or GameMaker are great options. And Godot shows a lot of promise as a fully open source engine.

Ultimately, the best game engine for a project depends on your specific requirements, skillset, and preferences. Experimenting with each helped me better understand their strengths and weaknesses to make an informed decision. I encourage you to do the same to find the perfect fit for your game.

TL;DR

– React: Great for web apps, tricky for complex games
– Unity: Powerful but complex for 2D, better for 3D
– Godot: Promising open source option, but less mature
– Construct 3: Easy for quick 2D games, but subscription-based
– GameMaker Studio 2: Robust 2D toolset but proprietary language
– Phaser: Lightweight HTML5 framework, great if you know JavaScript

I hope this breakdown of my experience with these diverse game engines and frameworks helps you on your own game development journey. The process of experimentation is as valuable as the final prototype itself. Let me know which engine you choose for your next project!