[4 Days to launch] How we created NALE’s card-game sequences in RPG Maker MV

NINA AQUILA: LEGAL EAGLE, SEASON ONE is out in 4 days, and we’re continuing our daily blogposts in the run-up to launch! Today, Ethan’s going to shed some light on how we created NALE Chapter 2’s card-game sequences, for the fictional game Dragon Fantasy Arena.

NOTE: before I get into this; this one’s aimed at people who are interested in RPG Maker, or game development. It might be a bit “dry” for a general-interest audience.

Origins

With NALE Chapter 2 being themed around a fictional card game, I realised early on that for it to work, I really needed to give players some sort of version of the card game to play.

External to NALE, I wanted something which could broadly act as a homage to “collect and battle” anime, of which card-gaming anime like Yugioh and Duel Masters are a part, but also other shows with similar tropes and themes, like Gundam Build Fighter and even Pokemon.

Internal to the game, this would serve two purposes; to help draw the players into the narrative by making the activity something they do as opposed to just see, but also, to approach “conflict resolution via combat” scenes in a wider storytelling context.

On the highest level, for NALE as a project, I wanted something like this to form part of every full chapter (Chapter 1, being something of a tutorial chapter, would not have one, but others would). As this was the first run at this, I knew Chapter 2 would set some standards that the rest of the chapters would follow, so it was important to get an idea of what I needed the card fights to do, narratively.

Card games as fight scenes and conflict resolvers

Card games in anime are, effectively, fight scenes.

“Fight scenes”, “Chase scenes”, i.e. action scenes which illustrate conflict in movies aren’t just a fancy display of martial arts. I mean, they can be… But for particularly good movies, or books, or anime, or anything, they’re a conversation. They pitch multiple characters against each other and have them use “the arcane”, be that martial arts, the ability to pilot a fighter jet, or even a card game as a way for the characters to reach each other.

Musicians to perform in Enter The Dragon-style hall of mirrors
“Remember, the enemy has only shadows and images. Destroy the image, and you will break the enemy.”
Enter the Dragon, final fight scene

Some of the classic fight scenes in various media demonstrate this. The “conversation” doesn’t always involve words; sometimes it’s about providing character growth purely through actions. Anime is somewhat infamous for the “talking during a fight” cliche; personally this always makes me think of the Guld/Isamu fight near the end of Macross Plus, where the two of them literally argue while fighting each other.

The Ultimate Valgern-On Showdown | Muv Luv Extra - Sumika's Route - Part 7  - YouTube
Muv Luv Extra took a unique approach to this, in that the characters play a game called Valgern-On which, I’m pretty sure, was intended as a “serial numbers filed off” version of Virtual On, a Sega arcade game. In MLE you don’t even actually play the game, but limited stills of matches play, with animated UI, to feel like you are. This was a pretty clever approach to make it feel like a game was present in the plot, but saved them having to make an actual game.

Anyway, the way this pertains to NALE was that I wanted to make sure that in any fight scenes, card games included, they had to provide the tools, first and foremost, for characters to have this conversation – to “banter”. The games are narratively driven, being a VN of sorts, so everything else kinda comes back to this.

High Level Goals

As always with NALE stuff, I started off by defining some high-level goals and working from that slate. I knew that the mode had to do several things:

Facilitate the character’s banter, and make it possible to tell story through the battles (see above).

Be turn-based, i.e. not require any twitch skill; this is a high level goal for all of NALE, for accessibility reasons. So-far nothing in the games has required twitch skill; if anything ever does, I want to make that optional.

Have a simple “always win” mode, another high-level goal for all of NALE, as the games are primarily driven by their story, and if a player doesn’t want the challenge (and just wants to play through) then I want to make that possible.

Be simple to understand & tutorialise themselves; I wanted the modes to be straightforward, and not require an extensive tutorial other than giving players the most basic information.

Be visually interesting, i.e. to be distinct from the rest of the game, either the investigation or court gameplay.

Above all is narrative – more of a guideline; the supreme understanding that the battles are a narrative tool, and features shouldn’t detract from that.

Note what’s not in the above list. The card game would need to be themed like a game, but it would not need to be capable of standing alone as a game; it exists to be part of the story. This relates to how “fun” the game is, also; it needed to be fun, of course, but fun for people who are engaged with the narrative; it didn’t exist for the purpose of entertaining those who otherwise don’t enjoy the game.

Armed with this, I moved onto prototyping.

Prototyping

The version of the card game in NALE is actually the third version of the mode overall.

I created a new project in MV, and worked in that, rather than in the main project, with the intent to copy/paste maps etc. over later. This ended up being a very useful practice which I’ll preserve going forwards, as it made it easier to throw stuff away which didn’t work.

Prototype 1 looked like this:

Fans will recognise something akin to Yugioh here. The idea was that players play cards in the top/bottom rows, and they would move around, a bit like an SRPG like Fire Emblem. I tried a few variants, such as having the players in the middle top and middle bottom segments, so cards could attack them. The swirls on the right were lives/health.

This, however, created a few problems, the main one of which was its verticality, which wasn’t good for cutscenes (in adversarial scenes, as players are likely on a widescreen display, a landscape approach tends to work better). But moreover, it was complicated; it was going to require a lot of bespoke animation to make this feel good with eventing logic, and soon, I scrapped the idea.

The second approach was more conceptual, and similar to Muv-Luv‘s example above, in that there would be no proper game, but just a few choices during each match. This led to the creation of the first version of NALE’s card-game arena, the final version of which features in the finished chapter.

This satisfied many of the requirements of the list, but after creating a proof-of-concept… It just felt a bit empty. I thought it could be better, and that led onto version 3.

For this, I took a different approach; I mocked out a doodle of how I wanted it to look, and then set about creating a very rough version in MV. Within a few weeks, I had this:

Fans will recognise some of the key elements from the final game, and once I had this, whilst it was slow and buggy, I knew that this was the approach I’d be taking.

Implementation

So how does it work?

NALE Chapter 2’s battle system uses MV’s battle system; that’s probably obvious to most people. However, in order to wrap MV’s battles into the card game rules required a lot of engineering.

For starters, the battles alone required many plugins:

But it wasn’t just about plugins; the bulk of the system is performed via in-editor eventing.

For those familiar with MV (and RPGs in general), on its most basic level, I wanted to pitch the player against an enemy, who was also effectively a player (with player-like stats), and have both the player and enemy summon creatures to fight each other,

Unfortunately, this was much more difficult than I originally anticipated.

MV, to my knowledge, has no “clean” way of getting a player character to fight a player character; like it makes a distinction between party members (i.e. player characters) and creatures (enemies), and it’s just not designed to screw around with this distinction.

To resolve this, I used a trick that ended up being very expensive.

Nina is a party member. When a battle starts, the script strip Dylan out of the party (and put him back when it ends).

Nina’s summoned creatures are also party members in the database, i.e. a party member character exists for every creature she can summon. These are removed from the party when killed.

The enemy duellist is a creature, with stats that closely mirror those of Nina.

The enemy duellist’s summoned creatures are actually creatures which are added to the enemy troop when summoned, and removed from it when killed.

In practical terms the creatures (both Nina’s and the enemy’s) use the same sprites, so the distinction isn’t clear, but this is actually how it works. This creates a big problem, because party members and creatures work very differently, so the state flow for each side is different. In short, this means that there are two entirely different solutions for…

  • Can Nina/the enemy summon a creature in a given slot, and the logic for enabling/disabling their abilities so they can’t perform illegal moves
  • Actually summoning/spawning the creature in the given slot
  • Detecting when the creature is dead and culling it, and freeing up the slot on the “board”

… essentially meaning that I had to implement all of these things twice.

This is where the plugins come in; they’re mainly involved with the spawning logic, the skill check logic (to prevent players making illegal moves), stuff like that.

There was also a fair bit of work to make sure that the damage etc. worked okay, because the formulae for each side was different (in practice, the damage numbers of creatures were randomised a few % to conceal that Nina’s creatures are slightly stronger).

As these states were so confusing, I actually had to create a testbed that would run battles for over an hour at high speed, so I could come back and see if the logic had broken down; it took about a week to plug all the holes, but eventually it was ship-shape.

Once I had this in place, it was quite straightforward to create the various duellists Nina would face, and the abilities she would gain. They all fit within the framework. The battles themselves were designed to be quite easy to finish (e.g. a red player who only summons red monsters); again, it was all about facilitating the narrative.

Visuals

Once the scripting was in place, I moved onto visuals.

First, I had to deal with branding, as I wanted Dragon Fantasy Arena to feel like a card game, as a homage to several real games – so I created the card-backs and logos, which feature in a number of places.

The inspiration here is easy to see, but that’s the point. Often, the cards in-game are tiny, tiny sprites, so I needed this to be very obvious. There’s no room for subtlety on a card that’s 8 pixels tall.

Additionally, when summoning creatures, I wanted to give the impression that the players Ire laying cards onto the field. To do that, I created an effect:

This animation is used for summoning red cards; blue and green cards have their own similar animation.

The next major job was an overhaul of the backdrops to reframe the action.

I’m not the biggest fan of RPGMMV’s battle backdrop method; instead I created fullscreen images, and played around with the UI and framing in order to try and create something a bit more exciting.

This also allowed me to raise/lower elements to keep the top/bottom of the screen free for the text boxes that would convey the story in several of the battles.

However, I didn’t totally reinvent the wheel. As NALE uses a great many modern RTP sprites, I stuck with a lot of this art, due to an in-world conceit – that Dragon Fantasy Arena is, in the Fledge City setting, based on that world’s most generic JRPG behemoth brand, Dragon Fantasy, a homage to Final Fantasy and Dragon Quest, so “generic JRPG” was what we were going for, and the art fit the bill.

Accessibility

I wanted to try and maintain accessibility as much as possible, as per the original goals – so the game requires no twitch skill.

There’s also a “cinematic mode” that players can select; this mode makes Nina invulnerable, so as a player, you’ll never lose – if you keep playing, you will always eventually win. Note that this mode is non-judgemental; it isn’t called “easy” mode; playing the game this way is just as valid as with the challenge enabled.

There were other elements too. Every stage backdrop shows a reminder of the element structure (blue beats red beats green), which in-game are termed as fire, leaf and water. This isn’t just cosmetic; by making the creatures and emblems different shapes and not just different colours, it helps ensure that the game can be played by users who are colourblind.

Finally, a later revision of the game made the mode potentially more accessible for photo-sensitive users, by removing flashes and toning down the roving camera (though as always, I recommend photo-sensitive users practice caution when playing NALE, as I can’t account for all forms of photo-sensitivity).

Problems

Not everything worked out, however.

Auto-battling was originally meant to be an option; players could select “auto-battle” and Nina would battle autonomously. However, I wanted Nina to make the right decisions so she would always win, and this ended up being surprisingly difficult to script. In the end, I went with the approach of the auto-win mode making Nina invulnerable as mentioned above.

Also, as a minor thing, the lane/attack logic was originally meant to be more complex, where the creatures would make smart choices as to which opponents to attack (like they would know who was most vulnerable to their attacks). This ended up being a real headscratcher until I tested it, and found out that even in a 3×3 scenario, there are just too few targets, so more-often than not, it works fine. It’s very rare to be frustrated by this as a player, so I just parked the feature.

In summary

All-in-all, the process took a couple of months, and I was broadly happy with the end result. It certainly would fall short of a mechanic around which to base an entire game, but then, as outlined above, that was never the aim of the process. We wanted to create a platform in which “story-battles” from a show like Yugioh can happen, and I feel we satisfied that aim.

We hope that fans of those shows, if they play NALE, will get a measure of that.

If you’ve read this far, the main thing worth considering, I guess, is that the simplicity of the end result kinda belies its complexity “under-the-hood”. I hope this teardown has been useful to you, and you can consider approaching similar ideas in your own projects. The battle system is actually very flexible once you get under its skin, and I love seeing people do amazing things with it!


Thanks for reading this!

NINA AQUILA: LEGAL EAGLE, SEASON ONE will be released on Steam on July 9th!

We’re inviting players to WISHLIST the game now; just click here and hit the “Add to my Wishlist” button!

We’re marking the run-up to launch with a range of daily blogposts about many different topics relating to NALE, such as how we achieved certain things in the editor, character bios and even a giveaway, which you can enter now over on Twitter!

Finally, if you’re a fan of the game, make sure you join our newsletter (and get a free pack of high-res NALE backgrounds for desktop displays & mobile devices).

We’re gonna have posts every day in the run-up to launch, so come back tomorrow for another!

And we hope to see you on July 9th over on Steam!

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s