BEM Gamification: Interactive Failure

Rob Haisfield, a really smart Behavioral Scientist with a knack for games, opened my playshop on Gamicon 2020 talking about failure states in games. His idea, and he is not wrong, is that many designers in learning are too focused on thinking about achievements and success states, but most mainly fail in designing failure states in a compelling fashion. Now, tomorrow I will be giving a webinar on Gamification in Education and how to transition from "active" learning to "interactive" learning, this is, how to make learning a two way communication channel through feedback loops (my topic of the playshop), and found myself thinking about failure states again, so I decided to put a little bit of this into writing.

Designing for error

There are a lots of fail-fast/innovation-through-failure mottos out there. People mostly have a clear idea that mistakes are a source for learning, but they understand failures as a natural possibility when dealing with complexity and unknowns. This works amazing in complex scenarios like building a startup or leading and innovation project, but in learning, teachers and systems are all about certainty and simplification. In the first case, failure is a natural state, in the second, you are designing against it. But in game design, we actually design FOR failure. This actually means that we can go out of our way just to create apophenias or misleading clues so the player can get lost in a controlled way, or create obstacles that are improbable to be tackled in the first try. Why? Because failure can actually be motivating if designed right, and success after failure can be much more appealing, as you can have a measurable sense of learning. Of course, many games don't work around failure, like many interactive dramas that are more about exploration, but, most of the time, players do like to have stakes built into place.

But designing for error is not an easy task, and most instructional designers and teachers have never been trained for it, so they insist on making mistakes punishing so people will be motivated to "avoid" the failure state, instead of embracing it as a means for learning. If you want to try using error as a way to improve the way your players learn about your game and content, here are some tips you might want to follow.

Make the failing state the default state

When I use this on real life learning scenarios, I explain to my players that they should be expected to lose (a lot), and will design my exercises so failing is a regular outcome. This way, it is not a competition between those that can and those that can't, but they are all on a playing field where most of them will be failing (this means adjusting challenge by skill, of course). In one of my spanish grammar courses I began the class by giving them exercises that most of them would surely fail. At first, because students have been prime to avoid errors, they would be shy and shameful of their mistakes, but after seeing that everyone is in the same page the anxiety would reduce: "it's not their fault!". In this sense, people talk a lot about early victories, but they never talk about the advantage of early failures (Flappy Bird comes again into mind). But this should be done with things that can be understood easily from their mistakes, so a second or third iteration is enough to bring them to those early victories.

Designing for failure means designing for the dopamine rush of success, which is increased by the experience of challenge. You can't maintain your players in a constant sense of losing, you need to take them into the state of success so they can, again, be able to measure the outcome of their effort. Remember, in many games the lose/win ratio can be up to 80/20%, but that 20% means that more than 5 iterations before achieving success can be infuriating and will only be sustainable in later stages of the game when emotional investment has been achieved (and a bit of sunken cost fallacy kicks in) and for particular challenges (aka. boss levels).

Low cost errors

Failing hits us directly on the pain and loss avoidance principles. Failing can be painful, especially if failure hits your self-serving bias or makes you feel the lost of time and effort. This is why startups and agile are not about failure, but about failing "fast". The idea behind this is that the less money and time you lose, the better, and early tweaks can improve your product. In complex scenarios this can actually backfire, because complex systems are not experienced as the sum of its parts, and testing a half-baked product can actually create the incorrect learning, but still, for many, that's much better than the possibility of dealing with failure after spending many resources on the project. In games this is tackled by creating checkpoints or short runs, where losing and retrying is not seen as a high stakes scenario. Think of games like Celeste or even Flappy Bird, where the cost of losing might be almost non-existent. You lose so little progress that you are compelled to retry and improve in small sprints.

Compare this with your typical scenario of a school or college project, where feedback iterations tend to be far-between. You ask a student to write an essay and grade the 5 pages that took 3 to 4 hours of the student's time to finish. Failing that essay can feel really punitive, specially if there is no possible iteration or if you are grading attempts using averaging systems. But what if you create more feedback loops where the student writes small chunks and are polished in several back-and-forth iterations until passing to the next stage, and are not graded on them. This would be the gamified way, when possible.

Remember that a failure state doesn't require a Game Over screen. Being hit by a bullet in a game is a failure state but might only take a toll on your hit points, which might recover after a while if you avoid taking more damage or by using a nearby medkit, which means the cost of each particular failure is low cost, and only the accumulation of mistakes is punitive.

Building certainty from mistakes

Games are about feedback, which means a response signal that can be used by an agent or algorythm to affect future game states. Positive feedback loops increase the chance of successful future states, but there is an art around working through feedback loops in failure states. It amounts to the level and clarity of information you are giving your player and giving too much or too little can break the learning cycle. Again, many gamification designers focus on success feedback, like creating unlockables, achievement badges, giving points and the such upon successful iterations, but failing states are way more important for sustained motivation, and these are usually done poorly (it has happened to me in the past). There are three main ways you can have this wrong:

1. You are not giving enough information to the player so a positive feedback loops kicks in. In this scenarios your players are lost and confused, because they know they are failing but can't understand why. You just throw a Game Over and that's it, or in school scenarios, an F.

2. You give ambiguos feedback. You place an interrogation mark in the border of the page and circle it, but never tell the student what that means. Or you put a question that raises more questions to the student than it answers. Or give a C to a paper but another with the same (or similar) characteristics get a B. Incongruence on the feedback rules is one of the main issues in education and one of the most common complaints from students.

3. Give the answer. This is usually done in "trivia"-like quizzes, were if you fail you receive the correct response in return. The problem with this approach is that it kills the kind of uncertainty that makes you retry and solve the problem, which is what creates the dopamine rush, and kills any kind of interactive feedback loop.

Interactive learning means getting enough information to iterate with another strategy on mind and knowing what to avoid or where to place you attention, but the feedback elements require clear patterns. In a platformer game like Mario, the world has consistent rules and mobs are activated on approach so player's can rely on expected patterns to try new approaches. When you lose in Mario is because the patterns are new to you, but after dying, you now can better tackle the problem because you saw the pattern. In Guitar Hero you have clear indicators depending on how accurate you were in your timing, which allows you to correct in future iterations. In both this cases, feedback is built to increase your certainty without giving the whole answer. Losing hints you in the correct path in a clear way, but doesn't solve the problem for you.

Again, when I taught writing in spanish (before I even heard of Gamification), I had a feedback system that was clear, consistent but never revealed the answer. I used three colored markers: red for orthography, blue for syntax and green for semantics. When I found a word poorly written, I would not circle the word, but the whole sentence, so students could search and find the offending rascal. I had several symbols with each marker to give hints on the kind of problems facing the student, but they had to come up with a correction themselves. Each time they managed a correction they would be able to see their progress, but it was THEIR progress. They were challenged to fix the problems in the least iterations possible because of optimization (it was not a fun work to do), but this focus their brains into avoiding repeating the same mistakes in the future.

Rewarding the failure

Ok, this one might sound weird, because of the whole "rewarding" thing, but this is actually done quite often in games, especially in competitive scenarios or some roguelikes. The idea is that losing, instead of being punished, actually gives you points or power ups that you can use later on to lower the challenge of the problems. In games this creates an artificial difficulty curve, where power ups lower the complexity of a challenge until a point where player skill can catch up. Runner games are a great example of this, because this games actually don't have victory states: you can only lose. What they do is, after each run, depending on your performance, you get some coins that you can spend on power ups that makes it easier to achieve higher scores, lowering the difficulty of the game.

In real life scenarios this can be hard to design, but it's not impossible. Imagine you start with a really hard math problem that your students can't solve. But each try is a "run", and after failing, depending on how much they managed to solve before making a mistake are rewarded with coins. Then they can spend this coins on getting hints from the teacher when they are in doubt of the next step. This hints don't have to be the correct answer, they can be just an overall "look at the signs and remember how multiplying is affected by them" pointer. Attention grabbers are great reward systems, because they can lower the cognitive cost of solving the problem, without giving the answer. The important part to remember is that you are not rewarding being a bad learner, you are acknowledging that problems can be hard and that interactive learning is about giving them tools to tackle the situations they are presented, especially when they are hard by nature.

Stakes and Revindication

This one comes from Rob's analysis of the Souls saga. Dark Souls is a very hard and punishing game, but has a cult of followers, and they deal with failure in a special way. When you create failure states you might need to create stakes, something you want to avoid losing. Again, in some low-cost scenarios, like in Celeste, you might not need high stakes, but if you do, like in Dark Souls, you need to design for that. In that game you lose all the souls you had collected since the last bonfire, which can be a big deal, as they are the main currency of the game, but the game gives you a possibility for revindication. If you manage to get back to the point where you lost, you can get them back. Dying creates a goal that is achievable (you got there in the first place, right?), which creates higher stakes (losing a second time loses you those souls forever), but not a sense of total loss.

This is something that averaging point systems actually fail hard to do. In Colombia universities grade on a scale from 0.0 to 5.0 and you need a 3.0 to pass. But each time you lose an attempt and get a 2.0, for instance, that grade in computed in your average, so your past mistake punishes you forever (literally, this will lower you average not only for that course!). Some teachers create revindication mechanics, where that grade can be scratched off if the student manages to have a better iteration, and that is a way of gaming the system to improve it, and more can be done. If what you lose might not be lost forever, you might try getting it back, which is better than having to let go.

Changing strategies and increased Challenge

In some games losing requires you to change strategies, which allows you to test different type of decisions. This can be achieved if losing is not about punishing by taking something you really need (like your grade), but something that is useful but not required. In The Darkest Dungeon each time you fail one of your characters is lost forever, which means that the next run must be attempted with a different team. In that game I had a boss that I had to attempt three different team configurations until I found one that better performed against that boss. This is the hardest strategy to pull of in real life "gamified" scenarios, it requires careful design of the problem itself, not just the feedback systems, and you need to allow students to try different strategies before they come with an optimal one, but I leave it here for those adventurous enough!

There is another way to tackle this scenario that can be easier to design for. In some games, making a mistake only increases the difficulty of the game, like falling from a cliff and now having to fight a horde of mobs to get out of there, or getting caught on a stealth game, which triggers a combat mechanism. In this games, if you die, you might try again the easier path, so the punishment is temporary, but increases the stakes of a low-cost failure. In this sense, in your class you can implement something like this: if you deliver an incomplete essay the next iteration requires you add an additional quote from an additional source to save your streak, if not, it will be noted as a failure but you can avoid the additional quote. Making the challenge interesting is part of the design feature which is the hard part, and need to have consequences for failing without making them punishing. Having consequences attached to a fictional character on a narrative can do the trick, for example, if the students care for that character.

Probabilistic Mistakes

One of the things that games have as a medium is that, when stakes are that low, players can afford losing some control over the outcome. This makes it the perfect way for creating interesting challenges that have intrinsic black boxes or probabilistic parameters, which makes understanding come before achievement. Let's go back again to our friend Mario: everytime you lose you might get a clear indication on how to solve the problem, but you might actually struggle solving the problem because your reaction times and button-pressing dexterity is probabilistic by nature (try to hit a log with an axe two times in the same place). This might push the player to have to try the challenge several times just because they messed up the timing. The idea behind them is that players can actually feel they are close to solving the content and just need a lucky break, which can be achieved in real life by creating quick challenges that incorporate these principles. For example, learning a language can be more fun if they have to a play a game were messing a past tense has some gameful consequences. You might understand the grammatical rule, but while speaking there is a chance that you mess it up just because your brain tends to naturally make this errors. This can be used to force the brain to reinforce the correct structures, while making clear that this mistakes are a force of nature and something that can't be avoided, but that can be made more interesting.

Discarding false clues

One final technique comes directly from mystery and detective games. I talked about apophenias, which are based on our ability of creating false connections between information. Game designers need to avoid them in early stages of a game because they can derail the experience and make the players feel lost, but then, they can be encouraged, if the correct failure states are designed as well. This happens in games like Monkey Island or the classic King Quests, where you had to try different approaches to solving puzzles, but you did it by clearly discarding apophenias and false clues. Basically a player "creates" a hypothesis and test it, but the game responds with "Why would a key be used on a window?". Now the player knows that keys can't be used in that kind of particular scenarios and that unlocking windows with keys is not a possibility. Of course, this must be designed with proper affordances to push the success state, but right now I'm focusing only on failing scenarios. This works really well when you can create consistent feedback rules, because if later on a key can open a window, you might throw you player off. Again, if you are teaching ruled content, like math or grammar or chemistry, this might work great, but it can be harder to pull of on more complex content with no algorithmical answer, but playing the detective game is a great way to teach through puzzle solving, if you are up to that kind of challenge.

A last word about efficiency

Designing for errors mean to have more iterations with your students and learners, which piles the work for the teacher. That is why you need to learn another play from the game designer book: make your feedback systems as efficient as possible in the first iterations (or rely on technology if possible). If you try to make big notes on every student mistake you will not be able to pull this through, but using colored markers and quick symbols might help a lot. Also, cooperative games where you give social feedback can be really helpful on the first iterations, but make sure you can make it so everyone is participating. This is by no means easy to pull off and efficiency has pushed in all those bad design practices in the first place, but this is something you can design around.

***

These are just some ways to tackle this problem and there are many more. Play games and think, "what did I got back from failing?" and you will see all kinds of design patterns emerge. Draw inspiration from them and try them out, this could have a big impact on the performance of your learners. For more, follow Rob Haisfield, you will not regret it.

Javier Velásquez - Gamification Consultant and Designer

Creator of the BEM Framework of gamification, which understand gamification as a design discipline based on the understanding on game design paradigms to build a better world. Contact me at [email protected].