My current game, Dragon Age Legends, was released this week. I wrote the following post as designer notes on the combat system.
One of the most lauded features of Dragon Age: Origins was its tactical combat system, which encouraged players to plan ahead and make interesting choices during battle. Indeed, although the system ran in real-time, the player could set a number of triggers that paused combat, to give time for deciding which skills to use and against which enemies. This feature allowed some to play Origins as almost a turn-based game that emphasized smart tactics over fast reflexes.
The Dragon Age Journeys Flash game built in parallel with Origins brought elements of the franchise to an actual turn-based game, in which battles played out on a hex-based grid. For the new Dragon Age Legends Facebook game, we built on top of what worked within the Journeys system (which itself was based on Daniel Stradwick’s Monsters’ Den Flash RPG).
For example, we borrowed the interleaved turn queues from Journeys, which means that the heroes and monsters take turns one at a time instead of fighting together as alternating groups, as is common in many group-based RPGs. Giving the player knowledge of which exact characters will move next creates some interesting tactical decisions. A monster who will attack sooner might be a better target than one who is a greater threat overall. Skills which disable or freeze enemies can be used intelligently to keep the most dangerous monsters at bay.
However, we simplified other mechanics from Journeys. Instead of using a hex-based grid, we adopted a simpler layout familiar to fans of Japanese RPG series like Final Fantasy in which the heroes and monsters line up on opposite sides of the screen is static slots. We built a 2 X 3 grid for each side, with front and back columns so that characters in the back column are protected from melee attacks by characters in the front column. This arrangement allows players to plan ahead by attacking a specific monster in the front line that, when dead, would expose a weak but dangerous blood mage in the back.
Another big change involved how we handled health and mana, the two most common stats from RPGs. Instead of using a bar-based system, in which a character might have 45 of 80 health points, we adopted a more chunky icon-based system. A character’s health is represented simply by 4 hearts, which are measured in halves, identical to the health system from the Zelda games. Mana is represented by single icons and as most skills cost just one mana, the number of icons a character has is shorthand for how many skills she can use.
This simplification had a number of advantages. First, the system had much greater clarity than opaque health and mana bars. These bars generally have the same size on the interface for the sake of consistency, which unfortunately obscures their true values. Although one character might have 20 hit points while another has 200, their health bars look the same on the game screen. In fact, most modern RPGs have superimposed text on top of health bars to give the actual values to avoid any confusion. With the iconic hearts, Legends avoids this problem as the graphics do not obscure any game data – what you see is what you get.
However, the most important reason to adopt the icon system is that it gives players a very tangible understanding of the consequences of their actions; the interface tells the exact effect of every possible action. For example, mousing over the “Power Strike” skill button next to a Hurlock shows that the action will take one-and-a-half hearts away from the monster while draining one mana from the player’s character. Mousing over a health potion shows that two hearts will be restored to the character. Mousing over a shock bomb shows that one heart will be taken away from all enemies. This transparency enables the player to plan ahead and make smart moves.
One reason so many RPGs go with a bar-based system is that hits points need to scale up over the course of a game, ranging from 10 hit points for starting monsters to over 1000 for bosses. With icons, Legends can never support hit point values that scale so high because the interface can only show so many hearts. Instead, the underlying character stats – attack, defense, agility, and luck – provide the scaling we need as players progress through the game.
Damage is calculated by creating a simple ratio between the attacker’s attack and the defender’s defense values. As this ratio increases to 2:1, 3:1, and higher, the damage value in hearts goes up. However, if the ratio remains constant, so does the damage. Thus, characters battling with 10 attack and 8 defense do the same amount of damage as characters battling with 50 attack and 40 defense, which means that the relative value of hearts stays the same. Similarly, agility and luck determine the odds of glancing blows and critical hits, by comparing the attacker’s luck with the defender’s agility.
As for mana, most skills cost just one point, with a few costing two and a handful costing more. The skills are all upgradeable up to ten levels (similar to the Japanese RPG Etrian Odyssey), which means that their power increases over the course of the game. However, their costs do not, so that players can expect to use the same number of skills per battle through all phases of the game. The costs can remain fixed because the better skills are simply an extension of the character’s growing power as he levels up.
Thus, the game’s simple and discrete health and mana values are maintainable across the game’s various levels. The players quickly gain an intuitive sense for how the game works (“shard bombs do one-and-a-half hearts of damage”) without having to memorize formulas or manage large, crooked numbers. Being able to think in small increments – a point here, a couple of points there – allows the player to fit a whole battle into her head at once, making combat a fun, tangible experience instead of a chaotic, stressful one.
I found this very intersting as I’ve been working on side project in my spare time with some similair combat elements while learning some C#. Some good things to consider about how players view the interface. Thanks for posting it!
-Ryan