Why revealing all is the secret of Slay The Spire's success

This is The Mechanic, where Alex Wiltshire invites developers to discuss the difficult journeys they underwent to make the best bits of their games. This time, Slay the Spire [official site].

Slay the Spire is a deck-building card game about careful attack and defence. And poisoning. And letting your own blood to amplify your damage, and hitting each enemy every time you lose a card, and gaining energy by hovering close to death. It’s a bit like Hearthstone, but it’s also a Rogue-like in which you ascend floors and find new cards and relics which power up your character in transformational ways.

It’s really good! And the secret behind it is a detail that seems minor, but without it your card-playing strategising would be for nothing. It’s the fact you get to see what your enemies will do on their next turn.

Slay the Spire knows that fun lies in certainty. It shows you what damage the enemy will do next and how many attacks they’ll make, or if they’ll defend or cast buffs on themselves or cast debuffs on you. Knowing what’s going to happen next opens a space in its randomness and permadeath from which you can make plans.

But it wasn’t part of developer MegaCrit’s original vision for the game. Back then, programmer Casey Yano and designer Anthony Giovannetti were focused on fusing a game like Dominion, the card game which probably founded the deck-building genre, with the Rogue-like.

This is what one of the first prototypes, from September 2015, looked like. A lot of what Slay the Spire is today is right there, from the names of its basic cards, Block and Strike, to its core energy design and map. But there was a problem. “Enemies were very random and we had no idea what they were going to do,” Yano tells me. “The difference between playing a defensive card against an enemy attacking versus playing an attack was all a guessing game.”

”Yeah, so a big part of it is that if you’re playing a JRPG it doesn’t really matter what an enemy is about to do a lot of the time, you’re just going to attack or cast your high-damage spell and you don’t really care what they’re going to do,” says Giovannetti. “No one uses the defend function in a JRPG.”

There’s a big difference between RPGs and Rogue-likes. In RPGs you can try out fights, often able to escape if they’re too hard or to reload a save if you die. Then you can grind a little so you can come back again and beat it. “In an RPG a battle is not life and death,” says Yano. But in Rogue-likes you’re always on your toes, tense with the awareness that if things go badly, they’ll probably screw up your entire run. And Slay the Spire’s earliest incarnation featured too many random attacks, the kind that are fine in an JRPG, but for a Rogue-like they were punitive.

“We needed to find out a way of seeing what the enemies are doing,” says Yano. Their first attempt was a system they call Next Turn. They placed a bar at the top of the screen which shows off player and enemy health bars and other information, and also a line of text which described what the enemy would do next. Here’s what it looked like in a prototype from March 2016.

“I don’t know if any turn-based game had done that before,” says Giovannetti. “We felt it was interesting, it was going somewhere. I actually had context to decide if I needed to defend up or go all-out.”

It’s fascinating that Slay the Spire should appear just as Into the Breach comes out, because Into the Breach, a Rogue-like tactics game from the makers of FTL, is also founded on players knowing what their enemies are going to do next. Yano and Giovannetti are big FTL fans but they didn’t know many of the specifics of Into the Breach until I told them about them. “I try not to look at unreleased games because I feel like it ruins the magic a little bit,” Yano says. ”The FTL guys and us are very similar people, I think.”

This new interest in showing enemy intents seems to me like it might be product of the way the fundamentals of the Rogue-like are being teased into new shapes, such as a card game, or Advance Wars-style tactics. And they show how their developers recognise that Rogue-likes were always founded on a strong dose of determinism. Think about playing Brogue and how, with experience, you can always make strong assumptions about what’s going to happen on the AI’s next turn because you can see everything around you. The magic lies in the complexity of the interactions between each little deterministically driven cogwheel, and your ability to use them to your advantage.

That’s exactly what Slay the Spire trades on, too. But the Next Move system brought up problems. ”One of the major ones was that when there were multiple enemies, what were we going to display at the top as the next move?” says Yano.

“We couldn’t have multiple enemies without it working badly,” says Giovannetti. “You could click on an enemy and that would change what you could see, but it was a big pain in the butt.” Playtesters continually played cards on the wrong enemy because they hadn’t selected it, and they had to click on each one to see what it was going to do.

“It was a pain in the ass,” says Yano.

And yet the way the enemy’s move was described in text allowed a lot of dynamism and nuance to what MegaCrit could have them do. They could introduce different states in each turn, so, for example, there could be a temporary situation in which if the player did precisely seven damage to the enemy it might trigger a special effect, all communicated through text.

But the Next Move system was so awkward that they had to drop it. MegaCrit were anxious that everything in Slay the Spire was visible at a glance, which would make it both easy to play and streamable. “We had to make some sacrifices,” says Yano. So they moved to a system that used always-visible icons, which couldn’t communicate as much nuance. “But usability improved so much that I don’t think we have any regrets.”

Megacrit had created the fundamental design that the game features today, and they call it the Intents system. But it took them a while before they were comfortable with it going all the way with showing what’s happening next. The very first iteration seemed to turn the game into a game of maths. While they wanted it to be transparent, they didn’t want players to be drowning in information. Having them add up attacks to figure out how many block points they needed to counter them seemed to go too far and they worried that players might be put off if they thought Slay the Spire was simply about numbers.

They were also dealing with implementing a big change to the game. Of the duo, Giovannetti is the card player (for proof, he runs Stimhack, a major Android Netrunner fansite and forum), while Yano isn’t so much. In fact, Yano describes himself as a rather impatient player, and he enjoyed the flow-state he got into while spending hours each day playtesting the game. Without precise numbers, he’d block-attack-block without thinking hard. “But when we introduced numbers, we felt they prevented you from getting into that. Change is always a rough thing,” he says.

“Yeah, it felt dramatic to us,” says Giovannetti. “Definitely in hindsight it’s correct, but when we were making it, it was a little concerning because we had been breathing the systems.”

“It’s unknown territory, because in every single game that does turn-based combat I knew of, the enemies’ intents are never revealed,” says Yano.”

So they came up with a halfway house, where attacks were indicated by symbols. A little sword meant the the enemy was going to deal between zero and five damage. A bigger sword was 5-10, a scimitar was 10-15, a butcher’s knife was 15-20, 20-25 was an axe and 25-plus was a scythe. They hoped the uncertainty within each bracket would prevent players from getting lost in the numbers. “But it was actually worse and required more thinking!” says Yano. “There’s only two of us and we didn’t have enough testers, so we were a little delusional.”

“The damage range made it like, ‘Does it mean the enemy is doing random damage? Do you have to be probabilistic about it?’ So that made people put people into more analysis paralysis,” says Giovannetti.

So they tested a version with precise numbers on their most engaged playtesters, who had hundreds of hours of experience with the game, and they saw them immediately take to it. And it didn’t affect their performance at all. It turned out that they’d already pretty much memorised every number. By exposing the actual attack values, all Megacrit had done was to unburden the players of having to remember them.

“That was another good sign, right, that if you get good enough then hiding that stuff doesn’t matter anyway,” says Giovannetti. “So why even hide it? It just makes this artificial memory barrier and that’s not a skill I was interested in testing anyway.”

And for new players, a layer of busywork and wondering was removed. Not a single playtester wanted to go back, and as they took the game to local game shows they noticed huge differences between people who played the builds with and without the precise numbers.

The dynamic range of the game, meanwhile, opened up. When players could respond to enemy attacks in meaningful ways, the range of damage they could score on the enemies rose because they didn’t have to conservatively block in case they were hit on the next turn. MegaCrit also noticed that players felt greater freedom to invest in strategically useful cards such as powers, which are energy-expensive but repay their value over the long term, because they could make the choice of either taking a hit or finding a safe time to play it.

“And it’s added a design space that we’ve only just started to scratch the surface of, like Spot Weakness, where it says if the enemy is going to attack it gives a benefit,” says Giovannetti. “We can do other cards like that as well, where effects matter based on what the enemy is doing. It opens up a richer possible play space.”

Revealing everything turned out to give everyone greater room to move, think and play.