Failure as part of the puzzle

I’ve been thinking about how parsers handle failed attempts, and how to make them not just funny but part of the solution.

I dug out my last attempt at a game (nearly 20 yrs old) and am impressed with previous me’s attempt and ambition.

Rather than the usual “that doesn’t work”, I was trying, and failing, to write an overly clever process to solve a puzzle

Curious to hear about particularly clever examples, and maybe source, of people getting this right?

Oh boy, if I don’t hold myself back I’ll just write reams over here.

Basically, a failed attempt by the user is a golden opportunity for the game to redirect the player’s attention to where it should be, IMO. It’s not necessarily handholding. It can be a nod along the lines of “I see what you did there, great idea. Unfortunately it failed because X”. So the player either solves X, or thinks of another idea. If you don’t want the player to waste time on solving X because that’s the wrong way, you can epxlicitly say “so you’ll have to come up with something else”.

Because a player doesn’t know what the solution is, their minds can go everywhere in trying to solve a puzzle, and I believe good design also means antecipating enough of their mistakes that you can use them as an opportunity to gently try to guide them towards what they should be thinking about.

A game is commuinication between the player and the game, and if the game just rejects failed attempts, it’s the equivalent of a guy sitting in the corner with their arms folded; you come to them with your attempt at solving, and he just stares at you and shakes his head, whatever you do, until you get it just right. I much prefer the game to be more communicative. You come to it with a proposed solution, it looks at it, acknowledges what you were trying to do, and tells you why it fails. Optionally go a little further, but at least this should be the minimum.

Sorry that I don’t have any examples right now, I hope this opinionated design principle might be useful too. :slight_smile: I can tell you that this is often the difference between a game that gets me to stay and try its puzzles for longer - because I feel I can trust the game, and my attempts are being acknowledged, so I am motivated to keep trying stuff, since, if the game understood me when I tried solution A, maybe solution B is worth a try - and a game that makes me feel terminally stuck. Emphasis on the “terminally”, because the point at which I quit and move on to the next game is not far off. Not because I can’t stand getting stuck; I just don’t want the game to be the guy in the corner frowning at me all the time and shaking his head as I try to throw the rubber chicken over the fence so that maybe the dog will jump after it and, on the other side, dig on the flowerbed to distract the neighbour so I can go inside their house to get back the lawnmower I loaned them.

I mean, the Babelfish puzzle from Hitchhiker’s is a possible example. Every failure tells you something about what you should try next. I feel like I remember that Above and Beyond! by Mike Sousa had a puzzle like that, although I don’t recall the specific puzzle.

But that is a very particular example in that it transforms it into a joke. :slight_smile: The point of the puzzle is that it tells you, each stage, what situation you failed to predict and account for, and therefore will have to include in your next attempt at a solution. It’s incremental. From the OPs description, I get the impression that may actually be what they’re trying to achieve! But it’s not quite the same as a failure that tells you what went wrong so you could try something else instead. In Babelfish, the game is leading you by the nose, purposefully makinn you try annd fail.

Games that kill off the player and end the game for failing to solve a puzzle are rude. As mentioned, teach toward a solution.

Or, kill off the player, but also have a healthy autosave system, so they can just reload and try something else.

In my recent game, this became an interesting thing. There is a point where something happens that can kill off the player – perhaps a little unfairly. But, that’s ok, they can just load the autosave and try again – now knowing that particular route is not a good idea! But loading an autosave means the game now has no idea the player died - all variables go back to how they were before. And while I don’t mind randomly killing off the player once or twice, if the player hasn’t figured out the solution, they may keep dieing over and over.

In the end, I had to store the ‘deaths’ variable as metadata so it would survive a reload. When the death counter hits 3, the game begins hinting that there’s a different solution, and the hints get more obvious the higher that number gets.

I had an idea for a game that takes place in the PC’s mind/memories. So after the player makes a mistake that kills the PC or otherwise makes the situation unsolvable, the PC goes, “Wait no, that couldn’t have happened,” and the game rewinds to the last known good state.

(I could never come up with a good story to fit that idea into, though.)

That’s Spider and Web, isn’t it? :upside_down_face:

“Don’t be absurd,” he says. “You’re no more a sightseer than the Old Tree in Capitol Square; and if you’d had enough sense to walk away from that door, you wouldn’t be here. You don’t and you didn’t and are; we caught you. And you’re going to start by telling me how you got through that door. Do you understand me?”

That’s kind of what happens in Spider and Web, if I recall correctly? Lines from the interrogator like “No, that’s not what you actually did.” But the game doesn’t give hints as to what the player should do instead.

Edited to add: I swear I was typing this at the same time as the post above! Great minds and all that.

It’s Repeat the Ending, too. The game rewards you (grants points) for failing in these ways. In my current work-in-progress, almost everything adds to tracked metaprogression, which persists across deaths. I like how that’s working.

I think with death specifically it just depends on the consequences. It’s hard to say, otherwise.

In general, I try to make low-stakes failure messages constructive in some way. One thing that’s been useful for me to think about the “near miss.” That is, what kind of message am I printing if the player fails, but gets close? I like to say something helpful in those cases.

You were! I saw you typing and almost stopped because “we’re both probably thinking of the same game, aren’t we?”

“That’s not how it happened” is a pretty well-known gimmick at this point; I see it in games now and then. I suppose it’s got a TVTropes page (although I’m not going to spend the time to look.)

The first big mainstream example may have been Prince of Persia (2003), which is framed as the Prince narrating his story to Farah.

I had a concept of a game that made this a feature. I started it but the scope escaped me. I combined concepts from Eternal Darkness and Alien Isolation into an interactive fiction. The player started as the antagonist and decided what power they would have.

The protagonists would exist in different time periods. You would be able to beat the monster as any of them but if you died your perspective would shift to the next protagonist, hundreds of years into the future. The choices you made would offer different options to later protagonists, helping, or hindering their odds of success.

If you ran out of protagonists then the game would of course end in failure.

It’s a common game trope, and has been since the last century. You can use failures to redirect the player to the right choice/choices or you can branch off failures to alternate paths or different optional/successful choices.

I’m working again on an old, unfinished choice game that utilizes this. It’s not an intentional rage game but some seemingly successful choices can end in death/defeat, while seemingly unsuccessful choices can branch off into successful or unsuccessful choices. I wouldn’t say it’s unique.

I like the idea that a failed attempt can still move the story forward instead of just ending it. A short, in-world explanation for why the attempt failed would help me stay in character, and it would make trying a different approach feel like part of the puzzle rather than a punishment.

And there’s the idea that “the story moves foward”, which implies that there is actual in-game progress, and then there’s the idea that “the player makes invisible progress”, which is, the attempt failed and nothing changed in-game but the player has learned information which will shape their next attempts. Kinda like, the former is a roguelite, and the latter is a roguelike (i.e., the former is “failed attempts result in resources to spend on later attempts” and the latter is “you failed, try again, but armed with information that will help you perform better this time”).

Both are awesome. The latter is probably more common. I don’t see the former often. I read that “I Have No Mouth And I Must Scream” actually tries to implement it. Apparently there’s a very specific set of circumstances that makes the game completely unwinnable, but for the most part, whatever you do, whatever results you get, it’s likely that you can get to the endgame scenario with a chance to reach a good (if maybe not perfect) ending. That is pretty cool.

The Infocom “Sherlock Holmes” sample transcript has something similar! It shows the player missing a train and presenting a message that any player would interpret as “game over, restore”; consulting the train schedule; finding out the next stops; and rushing to get to them so they can get on the train.

This is very neat, but hardly any game actually does this. (EDIT - turns out that plenty of games do. I’m just not playing them. Whoops!) This would have been an example of “a failed attempt doesn’t mean gave over” applied to gameplay. But in real life, either the game would end when the player missed the train or the whole thing would have been scripted from the beginning. (EDIT - or, it seems, neither of those two!)

In fact, this faux freedom the sample transcript implies bugs me a bit. If the Sherlock game is programmed to allow exactly this sort of thing, excellent. But it really doesn’t often translate to most games. (which, actually, is often the point of the sample transcripts: to get you in the proper frame of mind for this game and how this game works. infocom had a great idea putting these in. it trained you well for non-standard situations. their sample transcripts were never just “this is how you play IF”; they were always more “this is how you play this particular IF game”)

EDIT - There is also the “failure puts you on a different branching path to the ending”. Personally I dislike mutiple paths and endings, because that puts me on a frame of mind where I’m paying attention to branching points so I can later go back to them if necessary; very few things can make me forget the game and just focus on the structure (which I like to be transparent) like multiple paths and endings. But that’s just me. From what I read, there are players who love it at least as much as it leaves me cold. I am reminded of “Warden”, a (bug)folk story. Partway through I sort of stopped paying attention at what was happening, and instead was paying attention to the points at which I could divert the story should it all go down a path I didn’t like… (disclaimer: love the game and especially the series at time of writing. am eagerly awating more)

There are different grades of “a failure” and maybe that is boxing in the concept. “Not succeeding” is another facet of it but also perhaps not the best phrasing. To me it’s not always binary even when it seems binary. Having made some simple to borderline intermediate parser games, I’ve become aware of creating the unwinnable situation through accidental happenings. For the game I’m working on now, the specification has such a problem and the author of the book didn’t elude to it, maybe purposefully. It may just be an obvious thing that I’m still learning to recognize. As it goes in the spec you get a jug that is later filled with water. The water is part of the solution to an early puzzle. You also can find a length of rope attached to something before solving this first puzzle. The author has you break the jug to create a sharp edge for cutting the rope. The rope is needed for a puzzle later on that is solved by using the prize gotten from the first puzzle. If you break the jug before completing the puzzle needing water, well then you are now in an unwinnable situation for a story with one path through it. This is where I find that either the unwinnable scenario is prevented or an alternate path through the story where puzzle 1 can be bypassed is created. For the second choice I like to change how the scoring is done; perhaps I want you to do both, or do one and not get all the points and then be that kind of person who has to get all the points, or fail at the first and then find the second. I’m still learning the ropes of making parser games but I do know that hard won experience from making a game is rewarding.

Really? I feel like I’ve seen this plenty of times, especially in choice-based works (and especially in ones with Choice of Games-style stats and randomization). If you fail at something, the main plot keeps going, but maybe you ended up with a bit less of some resource, or you missed a neat bit of story, or it was a Morton’s fork all along and there’s no mechanical difference at all between the outcomes. (It’s customary for choice-based games to break up long spans of text with choices, and sometimes those choices don’t actually affect anything; ChoiceScript calls these “fake choices”, Ink could perhaps call them “immediate gathers”.)

That explains it; I exclusively play parser games. :slight_smile: No particular reason why; if I play choice-based games, I find that I don’t read the text. My brain goes straight to the choices. I miss out on a lot, I get impatient, I start lawnmowering, I start second-guessing choices. So yeah, if this is happening a lot in choice-based, that explains why I’m not seeing it. Not that it matters much, I guess. Except in the sense that “I shouldn’t go around saying games don’t do it”.

EDIT - A bit more on the topic of “my brain goes straight for the choices and skips the text“, but hidden because it's getting off-topic. So it's easily ignorable.

It may be because I actually love adventure games more than IF. Sierra notwithstanding, they have clear hotspots. And naturally I focus on them. But then again, in parser games I also tend to focus on the nouns because that’s stuff I interact with… but in parser games I have to take it all in and extract the nouns from the prose. I have to engage with the prose to extract the nouns. Funny thing, Blue Lacuna gives me keywords for everything interactable, and yep, you can bet that soon enough I found my eyes were skimming everything that wasn’t a highlighted keyword.

In choice-based, I have the choice spelled out. I don’t pay a lot of attention to the rest of the text, somehow, because my brain focuses on the hotspots; the nouns; the choices.

I actually mention this in my diatribe opinion manifesto opinion.

So it may be important not to overwhelm the player, and to realise that, at a certain point the player will stop paying attention to your pretty graphics and focus on the hotspots. But this is nothing compared to the players who stop reading your text to skim it for nouns. It happens. Not always, but at a certain point, it does. By then, the beautifully lush prose is not only a waste, it’s actively a hindrance.

I should add an asterisk, I speak as though this is an inevitability. I have every reason to believe it might be, but not necessarily at the beginning. Some players may enter this scanning-mode earlier than others. But I do believe that, when the player finds progress halted and stuckage is encroaching, this process starts to happen. It’s only natural. I’m stuck; time to identify the things I can do, the stuff I can interact with, to get unstuck. And once you get into that mode, maybe you can get out of it easily, and maybe you can’t.

Stumbling into this thread, I’m kind of surprised that no one has yet mentioned one-move parser games, where the game ends after a single move and you need to use the information from one play to better make progress on future attemps. (Aisle and Rematch are classic examples,) This seems to me like the logical endpoint of one way of asking how games can handle failure by treating it as a learning experience.