When you are creating something from scratch, everything is a discovery. You may stumble upon a new mechanic that has you rethink everything you’ve done so far. You may throw out everything and start fresh. When you are building an adaptation, such as the digital version of Sentinels of the Multiverse, the task is in some ways easier. Having a fully fleshed out design document in the form of the finished game is very helpful. And since Sentinels of the Multiverse is so well-understood by its die-hard fans, we realized that we had an opportunity to do a slightly unorthodox kind of alpha testing.
If you are familiar with Sentinels of the Multiverse, you know that its ruleset is simultaneously incredibly simple and completely fluid. Everything is governed by “play, power, draw,” but any card (or combination of cards) can change things on a whim. This aspect of the game brought us to our first big challenge in development: creating the rules engine.
Take the following example: suppose a card deals damage to every other target. The players get to decide the order in which those targets get damaged. Then suppose while the card is dealing damage, it gets destroyed (by The Wraith’s Combat Stance, for instance). The card needs to stop dealing damage in the middle of its execution. In the world of the tabletop, all of this is easily handled by the computer of infinite imagination known as the human mind. But in the less creative computer governed by 1s and 0s, every possible interaction needs to be well defined and handled. Even our simple example has complexity in order and execution, and ambiguous situations that we need to programmatically resolve. Now imagine that same situation with 20 cards on the table, and you can get an idea of how carefully we need to implement the system.
It’s pretty typical for teams to build internal tools, unit tests, and automations to manually test these sorts of things. This stage of development is rarely seen externally because it’s fairly technical, and honestly, not super fun. But we’re building an adaptation of an existing game. And more importantly, the fans of this game really know the cards, what they do, and how they affect a game. That’s when we had a brainstorm - what if we just let them play the engine directly?
Enter Mega Computer
As we started building the rules engine, we needed a way to exercise it and try out interactions between cards. The quickest way to do so was a simple console application that allowed us to play cards, use powers, destroy cards, switch between turns, and so on, in a completely unrestricted fashion. As the engine’s capabilities grew, the console application followed, gaining the ability to turn on “game rules mode” and be restricted to do only what players should be allowed to do. After all, that’s what will happen in the final game!
Once the console application had the ability to “play the game” as it were, we realized it could be a useful tool in the hands of Sentinels experts. While our unit tests covered many cases, and our manual testing found issues, we were (and still are) a small team. It would help immensely to have more eyes on the engine trying out the wide variety of situations you can get the game into. However, we did not want to complicate testing by including our graphical interface, still under heavy development.
During alpha or beta testing, it can sometimes be hard to figure out if what you are seeing is a bug in the engine code, an individual card doing something unexpected, a graphical glitch brought about by our interface code, or even a bug in Unity itself (seriously, it happens!). We realized the best way to make the rules engine rock solid was to make sure we were testing the engine, only the engine and nothing but the engine. We took a little time to clean up the console application interface and test out some access methods, and the end result was the Mega Computer.
Our testers access the Mega Computer via a text-only interface in a browser or terminal window. It runs in “game rules mode” just like playing a physical game of Sentinels of the Multiverse. Testers can choose any villain, environment, or heroes we have currently implemented. When in play, it looks something like this:
This is as close to the metal as you can get without typing 01110000 01101100 01100001 01111001 00100000 01100011 01100001 01110010 01100100 to play a card.
The Mega Computer has only been live in front of a limited set of testers for a couple of weeks, but has already proved useful and uncovered several bugs. When we finish a new deck, we add it to the Mega Computer, and testers are free to add it into the rotation. When you consider the amount of content that will require testing between all the add-ons and expansions, it becomes more clear what a great resource this will be over the course of development.
The foundation of a great tabletop to digital conversion is a correct implementation of the game rules, and the Mega Computer is an important tool for us to make sure we have that in Sentinels of the Multiverse.
If you consider yourself a Sentinels expert, please get in touch with us about gaining access to the Mega Computer. Be sure to include references such as links to forum posts where you demonstrate your accurate knowledge of the rules. You can also feel free to comment below.