Perilous Wilde is an Adventure game I made for the Adventure X Jam in late 2021. If you haven’t played it, check out the Perilous Wilde page on itch : it’s free! Normally Adventure X is a convention for narrative games (a cross-genre description they apply to everything between Grim Fandango and Mass Effect), but covid being what it was, they held a game jam instead.
Here I want to talk about the design of the game, namely, what I did that was sort of new, and whether the game lived up to its design goals.

But first, special thanks to the awesome musicians Brandon Blume and Donovan Jonk for making up the fantastic game score, to David Lloyd for his excellent Unity plugin Power Quest, and to Steven Don for just a tremendous amount of bug testing. Great people, go follow them.

What was new?

The biggest standout from its genre featured in Perilous Wilde is of course its dice rolling mechanic.

How the mechanic works is that there are 3 text color options with random outcomes. Blue options are “Uncertain” with a 5/6 chance of success, magenta options are called “Risky” and have a 4/6 success rate, and red options are called “Perilous” and have a 3/6 success rate. For each of those colors, the die will show a star for a success and a scythe for a failure.
There are also Gold options, which reward the player with a reroll point and expose them to more risk. Whenever the player fails a roll (gets a scythe), if they have 1 or more reroll point they can choose to either accept the outcome (except in the above tutorial) or spent at most 1 point for a reroll. All second rolls are final.

Since the game fundamentally has uncertain outcomes unlike a lot of narrative games which are deterministic, there is a constant push and pull in the design between having meaningful failure, and a complete-able game. There is another option which is player death and either reloading or restarting, but I elected not to do that, partially to help complete the game in two weeks, however any game made in two weeks would be short enough that having to restart it is not the biggest hurdle for a player.

Goals

Mostly due to the main mechanic, there are a few important design goals that become clear. These are: teaching the player the dice roll mechanics, having players make meaningful decisions with these mechanics, and having meaningful failure that doesn’t end the game.

The game holistically also has to be engaging, which I hoped to accomplish with clear objectives and narrative stakes.

Finally, there was one thing that wasn’t a game design goal, and frankly it showed! This was something relevant to any game design with random elements: game balance.

Teaching Dice Roll Mechanics

This goal had the biggest observable gulf between players. There were really two archetypes of playthroughs of this game that I witnessed, and they were people who had tabletop RPG experience, and people who were unfamiliar with it. In short, whether people understood the dice mechanic in Perilous Wilde was best predicted by them having played games with uncertain dice-based outcomes already.

Seeing the first dice animation took everyone by surprise, but the TRPG players immediately understood what was going on after reading the following text box, whereas others were either still confused or risked clicking past the information and learning nothing. There are probably a couple things at fault here. First, text can skip on a timer or after click (whichever comes first) which can cause text to be missed. Second, hovering over the blue text causes it to become white, and so it may not be obvious that an option is in fact colored. Third, there may not be enough dice rolls in the tutorial since it does not account for the first taking players totally by surprise.

I think this goal was mostly successful in being met, though there was a noticeable gulf in different players’ understandings. If I were to do this again in a longer project I would have to test with players unfamiliar with TRPGs more thoroughly.

Meaningful Decisions

Because of the difference in understanding between the two kinds of players, there was also a difference in how meaningful the decisions were perceived to be. Folks who were TRPG players who understood the differences in difficulty and who expected failure to matter reacted very differently during the following scene, truly puzzling over which option to pick:

Players less familiar tended to not experience as high emotional stakes, especially with this being their first true decision outside of the tutorial.

Sadly Perilous Wilde doesn’t have as many decisions as I’d like, as the one shown above. Decisions largely fall into one of three categories: whether to expend the consumable pistol shot, whether to expend the consumable reroll point, and whether to face a challenge or retreat. There’s no way for a first time player to know, but the retreat options, that make the player character back down from a task, are by and large poor. This leaves most decisions to be largely mechanical, albeit with the pistol decisions having a diegetic edge over the reroll points.

An area that could have been improved is the golden conversation options.

The plan was for these to involve a narrative sacrifice from the player — such as giving up food when their band can’t afford to — and in exchange to gain a reward for their heroism. However, they are largely non-choices, and the gold options are generally strictly superior. There is an exception with a fight against a toad monster where all failure options reduce the likelihood of winning the final battle (and so choosing to avoid the fight means you cannot fail), but realistically getting a reroll point is simply more powerful.

All-in-all there are some nice decisions, but some room for improvement too.

Meaningful Failure

Overall I’m quite pleased with how the differences in playthroughs can affect the different outcomes in Perilous Wilde. After the tutorial, there are 3 main kinds of penalties for failing rolls: delaying rewards, missing opportunities, and reducing the likelihood of future success. In the above screenshot, saving the woman in chains will result in her helping during future fights, turning magenta options blue, and blue options white (no chance of failure).

As Perilous Wilde is broken up into 4 days, many other failures will result in having to wait an additional day to perform some action. Finally, there are some failures (and some white options) that will prevent the player from experiencing some content. Failing to rescue Wu Khulan is one of them (more to be discussed in the balancing section), and the other is getting kicked out of town by the guards (which prevents you from later gaining a puzzle item). Overall these consequences I felt were pretty effective without creating an unwinnable gamestate, and largely understood by the players with few exceptions.

Additionally, all the player’s actions can come to head in the final battle.

The battle consists of 2 stages. First the ranged attack has 3 difficulties: based on whether the player has both a pistol shot and has saved Khulan, has merely one, or has neither. The charge has 4 difficulties: based on whether both the player has succeeded their first phase and still has their sabre, has merely one, has neither, or has cleverly managed to avoid the charge entirely. The fact that nearly every decision in the game affects these difficulties is wonderful, but it’s something that could have been better communicated to the player.

Likely the greatest lesson from this is to make sure all players have a better understanding of the dice roll mechanic, so that is has more narrative meaning.

Objectives and Narrative Stakes

Perilous Wilde doesn’t have as much in the way of puzzles, but it does have 3 major objectives. First, to hijack the weapons shipment reaching the town in 3 days time. Second, to complete the gunpowder recipe provided by Jacob to improve your odds. Finally, to prime the alchemist’s enchanted flask.

Attacking the weapons shipment is pretty clearly defined, and unavoidable. Characters at the camp will talk about it nearly every day, and it’s fairly clear to the player that they need to prepare for it. Additionally, in all of the first three scenes we are either told about or shown the brutality of the villainous faction, so I’m quite happy with the narrative stakes here.

Completing the gunpowder recipe I believe to be similarly well telegraphed. Every player I watched understood it as one of the main objectives of the game, and players that didn’t complete it were surprised that they could finish the game without it; they seemed to rightly think it was important.

One thing players were more hesitant to do than I expected was expending their pistol shot, especially to save Khulan Wu in the beginning. There are three opportunities to use the pistol (saving Wu, fighting the frog monster, and the final battle) and players can use the pistol in 2/3 of them provided they gather the gunpowder ingredients. Even if they had completed the objective they may have been unable to use it, as players almost always had the same shot in their pistol during the final battle that they started the game with.

Finally, many players misunderstood the alchemist’s flask. The alchemist describes in perhaps uncertain terms that his magic flask has to be primed (and how to do so), and players are informed again when examining or attempting to interact with the item, but the alchemist’s advice is the only text that isn’t missable, so it probably needed to have better information. Players who didn’t understand they had to prime the flask were confused when it wasn’t usable in the final battle.

Balance

Perhaps one of the biggest failures of the game in my opinion is the balance of different decisions. Namely, saving Wu Khulan in the beginning is critical for accessing several parts of the game and affects the game’s difficulty greatly. In a larger game this would be even more of a problem, and might not be so bad in a replayable 20 minute jam game.

There are three game states after the fight with Khulan’s captor, and 4 ways in which she affects the game, which is tremendous for the first decision in a very short game.
Rescuing Khulan grants access to all 4 affectations, failing to rescue her closes off all of them, and there is a third possibility where the player both rescues Khulan but accidentally wounds her which cuts off 1 affectation entirely and delays 2 more.

If you’ve rescued Khulan, she will always help out in the final battle. Additionally if the player also didn’t injure her, she helps out in the fight against the toad (an extraordinary 2/3 battles). Finally, any day after she has recovered from her wounds (or after you rescue her safely) the player can gain access to both the brimstone for the gunpowder recipe, and the mist for the alchemist’s flask, meaning BOTH secondary objectives are contingent on saving Khulan, which I don’t think is great design.

Another instance where the game could have been balanced better is fooling the town’s soldier. Getting kicked out of town by the soldier requires failing a Blue/Uncertain roll (5/6 chance of success) and a Magenta/Risky roll (4/6 chance of success) consecutively, a remarkably unlikely 6% chance of total failure that could have been higher.

Summary

All-in-all, I think Perilous Wilde largely accomplished its design goals with a few significant pitfalls.
First, not enough players properly understood the dice rolling mechanic, which I think means the tutorial should have had 1 or 2 more dice rolls to help players learn by being more engaging.
Second, gold dialogue options should have carried more weight or risk, as players were rightfully very quick to select them over other options.
Third, too much hinged on saving Wu Khulan in the beginning. While this probably does make the game more replayable, at least one of the secondary objectives should have been doable without saving Khulan.

There are also a few quality of life issues I need to keep in mind for future games:
make an option (perhaps as a default) for text that doesn’t skip should the player wait too long,
make the room exits more obvious (and make them hotspots on mouse over),
make debug (and maybe let players use) controls for forcing success or failure.

Extras

There was actually a 5th day planned, that’s still hidden in the game’s code:

Khulan wasn’t the only character planned on being captured. Ultimately I didn’t have the time to do everything, and I chose it to get dropped for being too similar to other parts of the game. The game also still has image files for the soldier carting off Jacob:

It was also planned for each of the dangerous scenarios to have 1 or more members of your band along to plan and ambush with, and depending on who happened to be there, their personalities would affect things differently; for example ranged assault would be the most likely to succeed with Wolf — the best shot — but he would be too impulsive to contribute well to diplomatic solutions. This too was outside the scope of the jam, but I believe would have been quite compelling in a full length game.

Thanks for reading!

Whether you enjoyed the game or just the article, I’m glad you came along for the ride! Perilous Wilde was a blast to work on and i look forward to doing more adventure games in this style.

Part 1: What is color cycling? | Part 2: Importing it into Unity

I’ll be starting with this image in I’ve been working on for just this article:

Our goal will be to create compelling color cycles in the river that will fall into a couple categories: creating a division between the top shore and the river, creating an illusion of motion of the river’s current, distorting the reflections of the far shore, and mimicking the fresnel effect of water.

Shoreline

We’ll start with the river-shore division since that’s the easiest and most straightforward, and provide the most basic parts of the practice. What we want to do is blend between the shore color and a water color in such a way that creates an illusion of motion. To do this we’ll capture the shore color, then create a lopsided gradient towards a water color and back again.

Next, we’ll set up our gradient for color cycling, and draw some solid lines to fill over with our gradient. Next we’ll create a long band of a single color using one of our obnoxiously bright stencil colors at the front of the palette. Since this water is far away, its motion should appear slower than water moving the same speed close to the viewer, so we’ll want the cycle to have a slow speed like 8, and make alternating stencil lines of 10 or so pixels. Be sure to enable the gradient for color cycling!

Once these points are all set up, we’re going to fill each line segment with a horizontal gradient. We can then toggle the color cycling animation key (default: numpad star) to see the result:

Applying this same general principle to the rest of the shoreline will create this effect throughout.

Reflections

Water distorts objects it reflects by noisy horizontal displacement. Reflections are also often blurred vertically, and can appear “chopped up” by waves so that parts outside the bulk of the reflection still occasionally reflect their subject. Objects close to the water appear to be much taller than those further away and can occlude objects seen normally in the rest of the scene. Finally, reflections can show objects hidden from the viewer, such as the underside of bridges. We’ll take this all into account when creating our static reflections, which we’ll then distort further with color cycling.

River Current Motion

To create a nice river current we’re going to have a few overlapping currents dithered together to create motion. However we’re going to want a few more stencil colors to accomplish this. We’ll start out by creating 2 new sets of stencils at the bottom of the palette. It doesn’t really matter what colors they are as long as they’re distinctive.
Next, we’ll map out the currents on a new layer using the same strategy as the first cycle. We want them to behave differently from each other, taking slightly different directions.

Using the first gradient, we’ll fill in a simple horizontal line contour gradient with a stencil gradient.

For the second gradient however, we’ll have to get creative. Until Pro Motion comes out with a Linear Contour Gradient fill, we’ll have to make do with a creative solution. We’ll select the gradient that isn’t cleanly horizontal or vertical to out brush, and increase the size of the image if needed. Next we’ll rotate it into a position where we CAN use the fill.

We’ll fill in each section of stencil with the other stencil gradient, rotate it back into alignment, draw it over the original, and then resize our image back to normal if needed. This will require some cleanup afterwards, but we’ll then have our stencil layers!

We’re going to be making several copies of each of these to fill over with different color cycles. Make sure you are editing COPIES and NOT the originals!

Next, we’ll create a stencil layer to overlay the two. Copy either layer, then press Shift+D convert the colors to your current foreground color. Select a stencil color and your transparency color, and press ALT+F1 to draw with both colors in a dither, then draw them in a new layer.

Then, copy one of the layers, pick the transparent color as a stencil, and paste over the layer dithered with a stencil color and transparency. Then, merge that layer over a COPY of the other stencil layer. You should now have a dithered version of those gradients!

I’m going to fill in all the orange gradient in with the purple gradient color-by-color to make a master wave stencil that we’ll use for several color cycles.

Distorting the Reflections

Now we’re going to start making some undulating motions on our reflections. We’ll do this in two basic ways, depending on how far the cycle is from the viewer.

For close up cycles, create a copy of the something to distort, in my case the reflection of the trees. I’m going to combine all the dark colors by selecting the paint dropper tool with “Isolated Fill” UNCHECKED, and paint over all green colors with the same green color. Then, create a gradient of the background color and one of the stencil colors and, using it, select the paint dropper tool in “Inline Countour Gradient” mode to color in the green from the whole scene. We’ll erase the other colors, as well as some of the stencil further away from the viewer, and come away with this:

Now we’ll paste our master water current stencil over it. It’s a bit hard to line everything up here, so I recommend creating a little marker to help. Draw overlapping rectangles of different colors on the master stencil layer and the stencil layer for the reflection. Alternatively if you’re pasting an entire layer, just make sure you paste at location 0,0 and everything will line up just fine. Either way, copy the master stencil layer, pick the transparent color with the stencil picker tool, and overlay the master stencil layer over the reflection stencil. It should look something like this:

Now, create a gradient that modulates in-between the colors of the water and the colors of the trees. Use the paint bucket to fill color-by-color over the new stencil outline layer, replacing the first color in the stencil gradient with the first color in the in-between gradient, and so on. Finally, set the new in-between gradient to cycle with the same frequency as the water gradient.

Using this same technique, we’ll apply it to a few other colors.

Distorting the Reflections of the Far Shore

This will be the simplest and easiest section. Find an area where there is a border between two or 3 related colors. Create a gradient that starts and ends at the same color, and create some lines around the borders of these colors like so:

Using the fill tool with that gradient and the linear gradient mode selected, fill in random areas within your lines to create the effect!

I’ll apply these effects to the the reflections of the far shore, sun, and sky to complete the effect at a distance.

Mimicking Fresnel

Fresnel, in the context of water animation, is the distortion of water relative to the viewer and object. Picture yourself standing in a pool of water, with your friend standing 100 yards away. If you look down, you can see your feet, but look at your friend and you see only their reflection! In the photo below, you can see some undersea rocks of the foreground, but soon enough only the reflection of the environment is visible.

Physically, this has to do between the angle of the viewer and the point on the water. Looking straight down is fairly clear, and further away is more reflective.

To do this, we’ll have a small wave cycle on the beach, and a few cycles for a gradiation between the water colors and the reflected sky color.

Let’s start with the beach! Create a mix of lines of two different colored stencils on the sides of the beach that face the current.

Create a gradient that blends the water current and the sand, then fill it into each stencil color in opposite directions using a linear gradient.

Because our current is fairly tumultuous, we’ll need at least 2 cycles to blend the sky and the waves. As you can see, the sky reflection I’m starting out with here gradually fades into the current via a dither. You can make the stencil for this by having a transparent color on one side and a stencil color on the other, pick the transparent color with the stencil picker tool, and painting the reflection onto that stencil layer.

Here I use the bottom two colors of the sky in the reflection to use as our gradation cycles, but you can modify those sizes as you see fit.

Performing a technique similar to the “distorting reflections” section, we’re going to use the areas of those colors to incrementally translate between the river current and the reflection.

Make sure the cycles furthest from the rest of the sky reflection have the most water-like colors, and those closest have the most sky-like colors

Notice that the bottom color cycle is made up of mostly water colors but has a few sky colors, and the top is the opposite. Additionally, the top doesn’t actually have any colors found in the rest of the water current; even the darkest colors are actually much brighter than the water current.

Voilà!

I hope this was illuminating, or at least a fun read! If you like what you see I’m always doing some kind of pixel thing on Twitter at https://twitter.com/thedeivore . As always, thanks for reading!

I’m always interested to see people try out-of-the box new things, so I thought I’d start a series on games that try out bold mechanical ideas. The first one, I’m excited to say, is the Quest for Glory series! The goal of these games is to combine Role Playing Games elements — by which I mean, random success based on character proficiencies — with Point&Click style binary puzzle mechanics.

These are games that, despite how many hours I’ve logged onto narrative games, I’d only heard of recently. The games were released thus:
• Hero’s Quest: So you want to be a Hero (Quest for Glory I) — 1989
• Quest For Glory II: Trial by Fire — 1990
• Quest For Glory III: Wages of War — 1992
• Quest For Glory IV: Shadows of Darkness — 1993
• Quest For Glory V: Dragon Fire — 1998

I chose this series to do first because, as an EGA graphics fan — and a fan of Point&Clicks in general — , I have a great appreciation for the games made late in the lifecycle of the display standard, and because I’ve often heard it heralded as one of the best Point&Click series.

Since these articles are going to be about how games innovate in their mechanics, I’m mainly going to be comparing this series to what came before it, and how they evolved from each other, however there’s always something to learn when comparing old games to newer ones as well.

Hero’s Quest: So you want to be a Hero (Quest for Glory I)

The game immediately let’s you know it’s not messing around with the RPG element side of things. Upon starting the game, one is prompted to pick between a Fighter, Magic User, and Thief class. Each stat is largely geared towards a single class, though Fighter and Thief have more overlap.

Many of its contemporaries have strictly lock-and-key type interactions: the player’s progression is dependent wholly on their success, and they will progress if and only if they produce the right answer to the right problem. There is only very rarely a way to progress without succeeding, or without a single specific solution.

Immediately, Quest for Glory has promised something different: two players choosing different classes will have to approach problems with different abilities, and players with a diverse set of skills will then have multiple angles of attack.
But I think there’s more to it than that. I believe Quest for Glory is more replayable than similar games with multiple solutions.

Replayability: Obvious Hooks, Unobvious changes

The replayability is most significant between the Magic and non-Magic paths, so that’s the example I’ll be using. What the above image doesn’t show is that the mage has an entirely separate list of spells. As a fighter or thief, the player is left wondering, “I know the Magic User can solve these puzzles too, but how?”. This doesn’t stop the player from figuring this out when playing a mage, it’s just that the game only lets one do certain things when one knows magic. At first this might seem artificial, but it’s not always apparent that there’s a magical interaction as a fighter.
Quest for Glory opens the imagination of future games by closing doors behind you as you pick a character. By making this clear fork early on that the player has to choose from, it doesn’t leave the player “stuck” thinking about how the game could have been played differently: it’s simply apparent. Furthermore, it implies to the player that they should put their trust in the game that there could be any number of differences; it’s up to them to discover the difference. It makes the same kind of promise inherent in the text parser, and many other good designs. The feeling that there’s more out there is so important. While replayability isn’t as much of a goal these days with games being more and more viewed as consumable, engaging curiosity like this is paramount.

Innovation: Success & Failure, Practice & Resources

As earlier, success is not simply a matter of having the right answer to the right question: many tasks are based on your stats, plus a random modifier. When met with non-lethal failure, the player’s options are:
1) Try again, if they have the resources.
2) Attempt something else.
While this is innovative compared to other puzzle games, there are a few issues that make it fall flat of more modern design:

First, success is still almost totally binary. Players either succeed at their task or fail. The penalty of failure is almost always either nothing, or death, which in a Point&Click mostly just means reloading. There are objectives the player can finish the game without accomplishing, but the act of failing itself has little or no narrative consequence.

Actions do cost resources: any action testing a stat consumes stamina, and magic spells consume mana. These cost time or money to replenish, and money can be earned with time, combat, or solving puzzles.
However, time isn’t really a true resource in the game as much as it is for the player in real life. There is only one instance where a task has to be done in an in-game day. I would have liked a very stat-heavy, number crunching game to have more significant resources, which is something that gets addressed a bit more in following games.
Except for combat, spending resources is not immediately visible. Transactions don’t show the effect on your bank account, you have to bring up a menu and do the math. Actions have a cost in stamina and mana, but you can’t see those costs except by keeping track before and after an action.

Tests are Opaque. There’s really nothing telling the player how difficult something is or how close they were to succeeding, they simply succeed or fail. This can make success feel very random, and make failures feel like an impassable brick wall: pointless to try and pass through.

Grind. Due to the opaque binary success and the RPG element nature of the game, the player has to perform the same action over and over again to reach a point with a chance of success. A lot of the time this means inputing a command over and over again until stamina runs out, recovering stamina, then doing it all again. There is no option to spend more stamina for a greater effect, and there is no real opportunity cost for grinding instead of doing something else since stamina recovery isn’t difficult. There is one exception to all this, which is a game that can be played for money:

Other Innovation: Dialogue

This is brief, but there’s a mechanic used once in the game that I’ve possibly never seen since, and I think it’s worth exploring because it gives more weight to dialogue.
Almost inevitably in narrative games, the player is presented with a choice of conversation options, and when one is pursued, the state of the conversation remains unchanged. The non-player character might as well be tied up under a heat lamp because the player is able to interrogate to their heart’s content. To some extent, it removes decision making from gameplay, feels a bit unrealistic, and becomes a bit of a chore to ask everyone everything.

The Baron of Spielburg, however, does not have time for the player’s shenanigans. When granted an audience with the Baron, the conversation topics matter: losing his interest three times will end the conversation, and indeed any chance of interrogating the Baron ever again, and some of those questions are worth points. This means players really do have to choose their words carefully!

Now, the game doesn’t tell you this, and in a pretty Sierra fashion one makes this mistake and then has to reload. However it’s not clear how many questions the Baron needs to be asked, and one can’t lose the game by not asking him questions, so it’s possible their is a real time/score cost for the player here.

My Personal Experience

I had a blast playing this one. The late EGA art really captures my imagination.

The whole of Spielburg forest really feels immense.

The forest is largely composed of about 2 screens of 4-way forest and 2 screens of forest corners with random object placements for texture, and the re-use of graphics actually played into the forest’s ability to get me lost which made it feel even bigger. It felt like it started out as a dangerous impenetrable maze and ended as a home, and had enough interaction that I felt I’d never know what was around the next corner.

The town was neat enough; it really only held surprises for the players who were thieves. Interestingly while the town is significantly larger than, for example, the Jerusalem bazaar in Conquests of Camelot, it’s still able to deliver on a kind of small town feel with lots of empty space and residences for many characters.

While a lot of Point&Clicks have towns in their settings, many try to give the player the impression that there’s more out there that can’t be visited because it’s not relevant to the story. In Spielburg, I get the impression that we’re seeing the whole thing, so there’s no point in suspending my disbelief that more town exists.

My biggest hopes moving forward were that success would be less binary, tests would be more transparent, resources would matter more, and a better system would be found to improve the character than simply entering a command 20 times.

Quest For Glory II: Trial By Fire

Time for entry number two!

From a mechanical perspective not a whole lot has changed. The player performs basically the same kind of actions, tests are still done in the same manner and with the same obscurity, but there is one major difference:

Events in the game happen on a strict schedule. Shema dances on particular days at the inn, and Omar the poet speaks every 4 nights. There are 4 elementals to fight, but you only have 2 days for each of them. On day 17 you leave with the caravan to Rasier, assuming you haven’t let the city be destroyed.
What this all means is that your tests are now given narrative consequence! If there’s something you need to accomplish like improving a stat, earning enough money for that sweet item, or overcoming a challenging obstacle, it may come at the cost of a missable event. And the game (specifically Shameen) is pretty good at telling you what’s happening in advance. As in the first game, a lot of events aren’t required to beat the game which lets players make mistakes/be penalized in ways that won’t ruin their fun, and have reasons to go back and play again. Trial by Fire isn’t a game that’s asking the player to probe very deeply and put together clues about its timeline, and it takes itself as seriously here as it takes its self on the whole.

My Personal Experience

I found that there was a LOT of dead time in this game. Often a task would come up, like defeating an elemental, which took very little time but was assigned 3 days of in game time to deal with, while nothing else new happened in the city. A lot of these elementals didn’t require stat tests but were only item puzzles, which made me further question why there was so much time for them — it often wasn’t for grinding if the player was behind.

My understanding is that no analysis of the game is complete without talking about the streets of Shapier.

I thought the streets were a super interesting approach to copy protection! They were large and expansive, following a map from the manual to get around was interesting at first, and after buying the in-game map it really wasn’t a bother to get around again. It felt like a good way to make the city seem bigger than it actually was.

However, the depth of the city did seem to come at a cost of making the desert seem totally empty (yes, I know, deserts are known for this, but it’s a game about adventure and magic, darn it!). The forests of Spielburg have a 17ish areas of interest: that is, screens within the forest that aren’t just random encounters and/or that lead to larger areas. The desert has exactly 4. If the forest was a dangerous and exciting place where I could stumble upon anything, the desert made me question why I even left the city where all the interesting stuff seemed to be.

The whole ending sequence of the caravan to the corrupt city, the cave of wonders, and confronting Ad-Avis was fantastic: it hit so many different emotional notes in great ways, and was just a lot more content for an end game that I was not expecting. Bravo!

Quest for Glory III: Wages of War

This time our hero arrives at an Africa inspired locale and appears in VGA for the first time! *cough*

The game now uses Sierra’s icon-based interface which, while not unique to this game, does contain a spell inventory and a few special actions like sneaking or resting.

Politeness as a Mechanic

While this existed in Quest for Glory 2 when talking to Aziza, I talk about it here because honor, politeness, and social standing matter a lot more in Wages of War. The player has to talk with several heads of state who think very highly of themselves, and saying the wrong thing can get the player kicked out of the conversation and even lose points. It doesn’t seem to make the game losable or anything so good on them here, though it’s a little strange how fighter/paladin oriented it makes the game feel when there is a thief class too.

My Personal Experience

While probably my least favorite of the four I played, QFG3 did some new and interesting things.
One thing I’m finding about a lot of these games is that the “points” tracker makes a lot less sense than a normal game. Many problems have multiple solutions that all seem valid, yet one will score the most points. Additionally if the game classifies one as a fighter but the player solves a problem with magic, that ingenuity is penalized.

More Narrative Minigames, Random encounters, and Trips

The biggest difference in how tests are taken was how many games there are. While for much of the rest of the series the only game that increased stats was combat, QFG3 has a lot more: spear throwing is good for strength/throwing, playing Awari increases intelligence, the wrestling bridge increases Agility. This was at least more interesting than repeating the same input over and over again in previous games.

The world map became a lot more interesting again and had a lot of interesting random stuff that could happen. Planning and preparing for your excursions became a little more involved since the player would be out in the jungle for days at a time, but I think could have been expanded upon more. For example there’s little stopping the player from loading up on tons of food at the start of the game and never worrying about it again.

Oh, and some of the art was just magical.

The art stood out to me a lot in this game, it has some great uses of perspective, and creative and strange nature. Any screen deep in the jungle just made my jaw drop a bit!

Quest for Glory 4: Shadows of Darkness

This might have been my favorite one of the four. I’m a huge sucker for dark fantasy and occult tropes, and everything in this game from its narration to its art to its narrative delivered time after time.

The game continues some of the series successful innovations but drops others: events that work on a schedule return, but Shadows of Darkness walks back the stat building games, and it’s much harder to get your self in trouble and miss events with poor dialogue choices. Unfortunately there’s not much to talk about here in terms of technical narrative innovation in this game, that is to say, the way one plays this game is not different. That’s not to say the developers did nothing new, but that technical narrative innovation is a narrow lens through which a game can be viewed.

My Personal Experience

For the first time in the series, the characters in the game came alive across the board for me. Part of it was the voice acting which I found to be very fun, but that’s not to diminish the actual events of the game. Just about every character goes from viewing you skeptically to warmly as you help more and more people, which was just so gratifying! And there were a lot of very emotional stories along the way, from reuniting couples, to reuniting families, to reuniting another couple… and another family… but hey, I’d be lying if I said it didn’t feel warm and fuzzy.

One area in this game that felt like the biggest missed opportunity was the castle Borgov.

These games have a lot of Easter eggs in them so it’s plausible I missed something, but very little happens while navigating this castle. I arrived for the first time rather later in the game, and was greeted by spooky music, creaky doors that set up a tense atmosphere that was never paid off. The castle is just empty cupboards and even more empty rooms! I only remember about 3 rooms of interest in the entire castle of 13 or so rooms. Due to how the story plays out there isn’t really room for a sequence of fighting guards, and the emptiness of the castle does mirror the emptiness of its owner, so there’s a bit of a narrative win there. But this large area that’s a source of mystery for a lot of the game being fairly anticlimactic left me wanting more.

Final Thoughts

It’s easy to see why so many people regard this as Sierra’s best series. Even from the first game it avoids many of the now tropy adventure game pitfalls of stranding players in either unwinnable situations or unsolvably bizzare puzzles. And if that weren’t enough, the series regularly delivers on memorable art, music, and gameplay moments.

As a bit of a confession I’m sure I’m not alone in, I feel like I rarely understood the connection between dodging, blocking, and not taking damage. Except for Shadows of Darkness where effects had very clear visuals, I never felt like I understood why I was taking damage. And when I won fights, it was mostly through stat sheet attrition.

Quest for Glory is a narrative game from 1989 that fashions itself after role playing games, so it’s perhaps not fair to judge it by improvements that have been made to both genres since then. The partial/scaling success popularized by Apocalypse World, the more transparent tests shown in modern CRPGs and adjacent like Torment: Tides of Numenera and Disco Elysium, and the modern autosave that enshrines inescapable consequences are the things I think most missing from Quest for Glory.

Overall I was extremely impressed by these games, and I’d have a hard time saying whether they or the Laura Bow series were my favorite now from Sierra. And if you’re looking for more like these, don’t forget to check out Quest for Glory designers’ new series, Hero-U!

Next time I’ll be chatting about Torment: Tides of Numenera, and how they took a similar approach to resource based narrative tests. Ciao, and thanks for reading!

According to Wikipedia, the categories of “Lawful-Neutral-Chaotic” and “Good-Neutral-Evil” come from the Role Playing Game, Dungeons and Dragons or “DnD”. The “Lawful-Chaotic” axis came out first, where “lawful” was intended to mean “honor and respect for society’s rules” and “chaotic” meant “rebelliousness and individualism” with neutral clearly being somewhere in the middle. The 1979 Dungeons and Dragons basic set included an additional “good-evil” axis, where “good” meant “altruism and respect for life” and evil meant “selfishness and no respect for life”. Like many components of the game system such as encumbrance or rations, the alignment system has remained in the game as a largely vestigial component from earlier additions with less mechanical relevance as the game has evolved.

Alignment as a Narrative Aid

I’m writing this largely as a result of listening to one of the more recent Classic Gamers Guild podcasts (which I enjoy, you should give them a listen!) which describes alignment as useful for “planning characters for writing” and “an interesting view in which to try to understand characters, their arcs, their motivations, and who they are.” I hope to convince you, dear reader, that not only are there far better tools for this, but alignment is genuinely bad for this purpose.

Every Alignment Name is Terrible

While Good versus Evil does describe opposites, Chaos is the opposite of Order, not Law: the opposite of law is lawlessness, or anarchy (not to be confused with Anarchism).

In the modern edition as of writing this (5th edition) these axis are different in subtle yet very far reaching ways. For example, Chaotic Neutral is described thus:

Chaotic neutral (CN) creatures follow their whims, holding their personal freedom above all else.

Why not simply call them whimsical, freedom loving, or similar? Chaos has a traditionally negative connotation: one that might be attributed by a character calling themselves lawful.

Along with lawful, “good” is one of the most poorly named alignments. There is a quote, “everyone is the protagonist of their own story”, or in other words, everyone thinks that they are the good guy. “Good” can’t be a useful descriptor if it simply means “one’s own morality”, so let’s look at the player’s handbook:

Neutral good (NG) folk do the best they can to help others according to their needs.

If the unifying concern of Good creatures is helping others, then “good” is really about “altruism”. Similar to chaos, “evil”:

Neutral evil (NE) is the alignment of those who do whatever they can get away with, without compassion or qualms.

would not describe itself as such, but rather as “pragmatic” or even “amoral”.

Like the connotation of “chaotic”, evil is described from a perspective of something that considers itself “good”. This kind of objective morality may be useful in a world like that of Lord of the Rings where “good” is by definition “serving the will of Ilúvatar”, but it is not so useful in writing deep characters.

Lawful Deserves its Own Section

Finally, we come to “lawful”, the most confusingly named of all.

Lawful neutral (LN) individuals act in accordance with law, tradition, or personal codes.

A personal code is extraordinarily different from acting in accordance to the law. Clearly, a character who is “lawful” is one who craves order of some kind. What “lawful” means then, in the modern context of alignment, is actually “Orderly”. This makes sense, as order is the true opposite of chaos.

Because of the inevitably self contradictory meaning, the term quickly becomes useless as a tool for assessing moral beliefs. What happens when a character’s personal code violates the letter of the law?

Let’s imagine a character with a strong moral code. They are known for trying to restore equity to the disenfranchised, fighting fair, and having an unwavering loyalty to the rightful ruler of their land.

Oh and also for dressing in Lincoln green!

Robin Hood is often used as the epitomizing example of Chaotic Good, which reads thus:

Chaotic good (CG) creatures act as their conscience directs, with little regard for what others expect.

Robin clearly has a personal code: he will consistently demand honorable fights where he does not have an advantage, he takes from those who have too much and gives to those who have too little, and he accepts the judgement of the rightful King Richard but not the corrupt Sheriff of Nottingham or Prince John, depending on the individual legend.

While Robin certainly has a whimsical side, for arguments sake we could imagine a character that didn’t. Such a character would be against the law because of the strength of their moral code. In the DnD definition of the term, they would be too lawful to be lawful.

Because of the misleading naming schema and its contradictory nature, I don’t think people should use the alignment system as an aid for creating characters with morals; in fact they should actively avoid it.

Alternatives to Alignment

There exist many better alternatives to alignment, some of which are themselves multi-axial morality systems. Since humans in real life tend to fall into normal distributions in regards to just about any category, binary categorization is often overfitted. It can often be better to see individual’s priorities to different, separate moral views.

Magic: the Gathering

MtG uses a 5 axis morality system in its design. In this system each point represents a core desire or goal. Points generally agree with adjacent points, and generally disagree with opposite corners.

While I don’t agree with the description of each description in the above image exactly, it’s close enough to what they represent. Characters are generally described by one or two colors foremost, with the understanding that all people will agree with each goal to some extent. The colors and their relationships give a good idea of how to push characters buttons.

Torment: Tides of Numenera

Torment, similarly, uses a 5 point morality system, but its points do not have special relationships with one another. A player can equally likely be passionate and justice seeking as zealous and ambitious.

I believe choosing between aspects the character views as positive is important, because these are where the real moral dilemmas come from.

Making your own Questions

Ultimately, there is probably no true substitution for coming up with what drives characters on a person by person basis. Having a couple beliefs is ideal, as it sets up characters for internal conflict when their ideals clash and they are forced to choose only one. The more the setting can respond to those personal beliefs, the better.
And beliefs don’t have to be just for characters: settings can have beliefs too. Whatever big questions are formed by how the world is changing, those are things the characters will have to grapple with no matter what.

Do you have an opinion on moral systems as narrative aids? Shoot me your opinion here on Twitter, I’d be more than happy to hear it.
Thanks for reading!

Sprites in Daedalus make use of Unity’s lighting system to appear with 3D-like properties.

Since Unity treats Sprites as flat 3D surfaces, it can do this by applying a shader in the sprite’s material that accepts a normal map, and using that normal map to calculate how light should be applied. But what does that all mean, and what how does one actually do it? I’m first going to talk about the technical details, but if you’re already familiar you can skip the next section on making normals.
You can also find a link to the shader I’m using at the start of the final section.

Normals and Normal Maps

First, let’s talk about what a normal map is and what it’s used for. 3D surfaces have a surface normal, that is, the direction perpendicular to the plane of the surface. In Unity2D, that plane is almost always the X-Y plane (green and red arrows), making the normal vector purely in the Z direction.

When people first started rendering 3D environments and assets, their computers couldn’t afford to render many different surfaces. Early 3D games are famous for having an extremely blocky aesthetic. One way to get around this is a shader that uses vertex information to estimate lighting and interpolate it.

It works by using the normals of the vertices rather than the surfaces, and interpolating between them to estimate the lighting at each pixel.

However, for a much finer grade control we can use a special shader with a normal map. A normal map is a texture that describes modifications to a surface’s normal.

Psychadelic! But what’s up with those colors exactly? And why is it all so purple?

As you may have figured out, the normal map is mapping color to different normals. Since color is represented as a 3 part vector of Red, Green, and Blue, it makes sense to map these colors to their respective directions of X, Y, and Z (you can even see this mapping in the Unity3D view picture above).

Let’s take a look at the different color values to see what’s going on. There are a few things interesting about these values. First, the center of the sphere and the background color are the same. Second, the blue value ranges from 50% to 100%, but the red and green use the whole spectrum. Why?

The mapping of 0 through 255 of a color value is mapped to the -1 to +1: a value of 128 is mapped to 0. This means that a normal vector of (0,0,1) will map to (128, 128, 255), which happens to be the background color. Remember how the normal of the 2D surface was entirely in the Z direction? That means that a light ray shining into the surface normal will be reflected back along the surface normal. A color that’s 50%R, 100%G, 50%B will face up (positive Y); a color that’s 75%R, 25%G will face to the bottom right; 0%R, 50%G will face to the right, and so on.

In this example, there is a light in the center of the console. Rix is lit up on her chest, her chin, and the bright pink part of her hair. Given this, we would expect the normal map to have a color on her chest that looks like the right of the sphere example, a color on her chin that looks like the bottom-right of the sphere example, and a color on her pink hair highlight that resembles the top-right of the sphere example. Not only does this all check out, but other body parts like her elbow are colors that face away. Nice!

Creating a Normal Map

There are 3 ways I’ve explored of making a normal map: using an external tool, drawing a height map by hand, and drawing a normal map by hand.

For the first, I’m going to plug a tool I think is phenomenal, SpriteDLight.

This app can take in a sprite sheet, gives you a few options as to how sharp and deep the bumps are, and spits out a normal map sheet that can even be previewed within the program! It takes into account differences edge differences between different colors and the transparency, and is excellent for characters.

Since sprite sheets are a bit of a different animal, I tried two ways of making normals for them: converting from height hand painted height maps, and pure hand painted normals.
Let’s take a look at a section of the ship’s sprite sheet to see what we’re giving normals to:

In a height map, the brightness of a color corresponds inversely with its depth: darker colors are deeper. They don’t have to be grayscale, but the system I believe only looks at a colors brightness regardless. They work best when the sprite sheet contains no unnatural logical transitions: when you put tiles next to each other that are of different heights and would NOT be next to each other in games, you can get some problems.

As you can see, the map is not entirely filled out because I soon realized the process would not work well on my particular sprite sheet, and that it might be hard to make sheets that meet the requirements listed above. After trying this out, I instead began to hand paint normals, using a palette of 17 colors, and this worked out much better for me:

This is the approach that I would generally recommend for people: it doesn’t take a lot of understanding to make work, and one can paint with fairly broad and non-detailed strokes to get a good result.

Use a Normal Map in Unity

The current normal map shader I’m using , which I hope to find the original source for soon, uses a bump map argument, “Normalmap”, to shade both sides of a Sprite (for users that flip sprites by multiplying the X scale by -1).

When one creates a new Sprite via the Create menu, Unity populates it with a few default options, including the “Sprites-Default” Material which uses the “Sprites/Default” shader.

Further information can be found at Unity’s rather nice documentation page on normal maps. To sum up, you’ll need a material with a shader that uses a normal map, attach that to your sprite object, and supply your custom normal map in the normal map argument. Pop a few lights into your scene and viola, dynamic lighting!

If you liked this, consider giving me a follow on Twitter! I can be found @thedeivore and I post updates to this and other projects as often as I can.
Thanks for reading!

Dynamic Sprite Lighting in Unity was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

Today I’m going to be doing something a bit different, and that’s talking about a wonderful game I discovered through other members of the Adventure Game Jam in 2019: The Crimson Diamond!

In the Crimson Diamond, the player takes the role of Nancy Maple, an aspiring mineralogist looking for an in at her university by learning about a recently famous diamond discovered in Crimson, Ontario. The game is is a love letter to the EGA text parsers of the late 80s, and in particular one of my favorite games, The Colonel’s Bequest — the first Sierra game starring Laura Bow.

Each game of course has some advantages the other lacks. The Colonel’s bequest was made by a team of writers, artists and programmers. The Crimson Diamond (at least as far as I know) is a solo project made today that can benefit from an adventure game engine and years of decades of history of design decisions. Keeping in mind these differences, I’ll still be largely comparing The Crimson Diamond to the Colonel’s Bequest since that’s a target it’s very clearly trying to hit.

After a brief place-holder introduction getting the protagonist to their destination, the game drops you off in the Crimson Lodge to begin exploring.

Art

The first thing one notices is that, for a 4-bit color game, this thing is one is pretty! A lot of the backgrounds feel like they could have come straight out of an EGA game.

While Nancy’s walk cycles are pretty slim, she has a whole host of other animations, even for seemingly trivial things like sitting down in the study, that surprised me and made the game feel polished. In addition the speech animations are also quite nice, and characters even have multiple speech expression animations!

The game doesn’t have a lot of sound yet, which can make the game feel a bit empty. The introduction music is tinny and hard to listen to, but otherwise the current sounds in game are quite serviceable. One thing I would like to see is more ambient sounds to make the game feel more alive. I don’t know what a lot of the wildlife noises would be like in the region, but perhaps small animal noises while outdoors at least.

Usability

The UI feels quite a bit different. In a text parser game, your hands are going to be on the keyboard a lot, so when you’re not merely navigating but interacting, you’ll want to use the arrow keys or numpad a bit. In Bequest, tapping an arrow key once in a direction Laura is NOT currently traveling will send her off that way, and tapping that same direction again will stop her. This has the benefit of not being as tiring as holding one’s finger down, but can have a tendency to overshoot one’s destination, which in Bequest can actually just kill Laura pretty frequently.

Nancy can walk in one of two modes: hold-to-move or press-to-move. Holding allows the arrow keys to transition between cardinal and diagonal directions to more easily navigate obstacles, and pressing is mostly identical to Bequest. There is a minor distinction in that Nancy has turning frames during which she cannot accept input, so rapid key presses can get lost. I would favor removing this input block.
Currently in Diamond, the player can skip text by holding a key down which can help to skip gobs of text of the player is replaying a part of the game, but it has an unfortunate interaction with hold-to-move:

Anyway, seems like there’s not a lot to do in the starting room, but you can catch up a bit with Kimi if you missed part of the intro. One thing that’s immediately noticeable is that you can’t right click to examine things like you could in the Colonel’s Bequest, so I imagine there will be some objects’ descriptions that I’ll have to fight the parser for.

Additionally, Nancy will not automatically open doors, and when commanded to do so will not automatically walk through them like Laura will. And as seen in the previous gif, there are a LOT of doors. Nancy also handles a bit more jerkily: hold-to-move moves 7 pixels at a time at time intervals determined by player speed, which can be a pretty large portion of the screen. It’s actually surprisingly difficult to enter the initial doorways this way, since they are only about 9 pixels tall and are right next to the screen edge! She also moves up and down vertically regardless of the perspective of the scene, which makes navigating around obstacles a little more irritating, often crashing into walls when moving up or obstacles when moving down. The “perspective walk” in The Colonel’s Bequest is able to take advantage of the way rooms are laid out and avoid obstacles this way.

You can also open all kinds of drawers and cabinets and get cute animations for doing so, but they are almost all empty. Exactly one of them gives a message that it may have something later, so continuing this game it is probably the only one I would ever check again.

Mechanics

The text parser works much the same as one would expect, and most of the game is about questioning the characters via the text parser, learning about them and the world, and using that information to make new discoveries. Diamond now has a readable notebook which displays objectives that progress the game, which is quite nice. Nancy is also able to listen in on conversations to learn more about the characters.

Currently the game does have you make some gameplay decisions about spying: Nancy can only eavesdrop when no one else is in the room, so she has to navigate the world to that state first. If this is explored further, it would be an improvement on what was done in the Colonel’s Bequest which had no real decisions involved in spying: it was always safe and straightforward to do so, and the player should always do it.

That’s all for now!

I’m definitely looking forward to seeing more of this game! I’ll probably do another one of these once the full version is out.
Thanks for reading!

In my first part, I described what color cycling is and how it has been used in games to date. Today, instead of a how-to on making your own color cycled pieces I’m just gonna skip ahead to part 3 for now: Using color cycling in Unity, and snazzing it up beyond the discrete cycles from Pro Motion to blend between the frames using “Blendshifting”. As far as I can tell, the first person to do this was Joe Huckaby back in 2010:

Interestingly, the above gif is really unable to capture the same image on the website. This is because while the gif’s update frequency is limited by the number of frames in the image, the HTML canvas is limited by your computer’s frame rate. Cool!

So what do I do with a Pro Motion .pmp file?

Joe’s code uses the “.lbm” extension of the old Deluxe Paint DOS editor. Luckily Pro Motion exports to this filetype, so no “.pmp” parsing for us! With a few modifications to the lbm2json program from Joe’s repository, we have a JSON file that’s up to date with the current standards. Let’s take a look!

These JSON file have 6 fields: “filename”, “width, “height”, “colors”, “cycles” and “pixels”. Colors and cycles are themselves JSON objects: colors has “R”, “G”, “B” which are 0–255 values, and cycles has “reverse”, “rate”, “low”, and “high” which are all positive integers.

The first three are all straight forward. Since Pro Motion produces images with a 256 color palette, the “colors” array has 256 objects each with three color channel values of 256 possible values each. “Pixels” contains a number of entries equal to the images width times its height, and are each 0-255 corresponding to an index in the “colors” array. In the example image above, the 8 purple sky colors are the first ones in the palette in the lower right, so they take up indices 0-7 and each entry in “pixels” that uses a sky color will have a value from 0-7.

The “cycles”, or gradients, have the fields “reverse”, “rate”, “low”, and “high” as described above. “Reverse” describes how we move through the cycle: forwards, backwards, with a sin wave, or forwards then backwards. “Rate” describes the speed of the cycle, with a higher rate having a faster speed. Finally “low” and “high” are the indices of the first and last entry in the palette, respectively. The above gradient starts on the 64th palette entry and goes through the 72nd, so it’s “low” and “high” are 63 and 71, respectively since proper arrays start at 0.

Shader Magic

In order to draw these properly, we’ll need to save the indices, palette, and cycles information separately. Via the code FOUND HERE, I export an image of the same width and height as the original, but with every pixel’s color equal to its index instead of the color value. This will allow the shader to hook in later on.

While this looks alien, remember that the color values really have nothing to do with their original’s values: the sky is black simply because the sky colors are indices 0-7. The greenish wall colors in the original image are right at the end of the image, so their entries are 249-255 and are very bright, since pure white is 255. The smoke right in the middle of the palette and shows up about 55% gray, as we’d expect. We also export a palette image, and create a material, sprite renderer, and script to hold these values for our shader, which is actually quite a simple one, at least for now. Its business end is the fragment shader, which is as follows:

All this does is grab a color found at the pixel’s location (from 0.0 to 1.0), convert it to a 256 color (from 0 to 255), and return a look-up value from the palette for that index. Without any special modifications, we get an image that looks like a gif:

That’s our image with its color cycles running as can be seen in the editor, with the notable difference that we don’t have to have aligned cycle times. Image projects that would export to gifs with 10,000+ frames can be very safely dropped into Unity and can have any misaligned rate you may want.

Blendshift

However, since we have all these nice cycles, we can now interpolate between them on a frame-by-frame basis, known as blendshifting. How is this different from what we’re already doing? Well I’m glad you asked!

As you can see the Blendshift approach creates a smoother gradient without as much of that choppy feel from the above gif. The approach is fairly straightforward: instead of throwing away the partial frame in our calculation, we just use it to interpolate between the current palette index and the next as:

framePalette[currentIndex] = truePalette[IndexNext] — (truePalette[IndexNext] — truePalette[originIndex]) * (cycleOffset%1);

This gives us a smooth result in Unity!

In my next part I’ll go through actually making a .pmp or .lbm color cycling file in Pro Motion!

The first video game console I fell in love with was the N64, and at the time I was blown away by Super Mario 64. One of the first things I can remember designing as a kid, racing home for dinner from my friend’s house, were ideas for custom levels for the game, scribbled down on paper that probably remains in a box somewhere in my parents house to this day. I was dimly aware that people made brutal romhacks of the older 2D mario games, but it was only recently that I decided to see if there was a community for hacking SM64.

As it turned out, there were a surprising number of full length SM64 hacks, some even featuring over 150 stars! And it’s not all editing 1s and 0s, there’s a slew of custom tools made specifically for editing this game for object placement, importing level geometry, and editing text.

However one thing most hacks have in common is the lack of custom code. While they have unique star counts, level geometry, and textures, they all for the most part share the same moveset, the same cap powerups, and the same set of objects found in the game. The most notable exception was Super Mario 64: Last Impact which managed to recreate every powerup from Super Mario Galaxy 1 and 2 including a rideable Yoshi using assembly code injected into the ROM file. Clearly the information was out there to do anything. So, I decided to try creating a parkour wall running mechanic for Mario!

The two primary resources for injecting your custom code are the documentation (largely from Origami64 wiki) and a trusty debugger of your choice (I’d recommend the Project 64 debugger mod by Shygoo). The human-readable language this debugger provides is assembly (ASM). I’ll cover some ASM briefly, but for a more thorough explanation check out this material on Hexidecimal, ASM, and SM64 specific commands.

The right side of the debugger shows a line by line view of each ASM command and its arguments as disassembled by the debugger. ASM takes the form of a series of cryptic abbreviated commands, followed by a combination of 2 digit alpha-numeric registers and hexidecimal immediate values. Hexidecimal is a base 16 number system useful in computing because a single digit can represent 4 of the computer’s ones and zeros in binary (2⁴ = 16). Since conventional decimal runs out of digits at 9, we start using English letters. In hex: 9=9, A=10, B=11, F=15, and 10=16. Here’s a code example:

BEQZ T3, 0x80370454

The command BEQZ stands for “Branch on EQual to Zero”. It’s part of a family of commands called branch commands that examine some condition and jump to somewhere else in the code if it’s true; BEQZ does this if its argument is zero. So what is it’s argument? Why, it’s the register T3, which is a place a temporary value can be stored by the computer for math and logic operations. T3 can be seen on the list of registers on the right of the debugger: its value in the image is 00000000 801A6BC0, a hexidecimal number. Finally, the last hexidecimal immediate argument for a BEQZ command represents the location in code to jump to should the comdition be met. So, if T3 = 00000000 801A6BC0, BEQZ T3 will fail to jump to its immediate location, and execute the next instruction as normal. A more complete list of ASM commands can be found here.

Another related command is the BNEZ command. This command does the opposite of BEQZ: BNEZ stands for “Branch on Not Equal to Zero”. As you might expect, we can use this to negate a BEQZ command. One interesting place to apply this is the code line 80256498

BNEZ AT, 0x802564BC

which branches on perpendicular wall collision; it’s the part of the code that gives the player the opportunity to walljump on perpendicular walls. So, if we swap it out for a BEQZ we should be able to walljump on parallel walls!

Now, let’s see what injecting a custom function looks like. We’ll be looking at an example that overrides a debug function (it does nothing, but the code calls it anyway) to allow the player to jump override any state to jumping by pressing L:

// [ARMIPS 0.9+] Moon-Jump Example by Davideesk

// When the player holds the L button, Mario will float up into the air

.defineLabel BTN_L, 0x20
.defineLabel MARIO_STRUCT, 0x8033B170

.orga 0x861C0 ; Set ROM address, we are overwritting a useless loop function as our hook.
.area 0xA4 ; Set data import limit to 0xA4 bytes
addiu sp, sp, -0x18
sw ra, 0x14 (sp)

// Tests if the player is holding down the L button.
.f_testInput BUTTON_L, BUTTON_PRESSED, proc802CB1C0_end

li t0, MARIO_STRUCT
li t1, ACTION_JUMP
sw t1, 0x0C(t0) ; Set mario’s action to jumping.
li t1, 30.0
mtc1 t1, f2
swc1 f2, 0x4C(t0) ; Set mario’s y-speed to be 30.0

proc802CB1C0_end:
lw ra, 0x14 (sp)
jr ra
addiu sp, sp, 0x18
.endarea

Let’s start with the bread and butter of functions:

.orga 0x861C0 ; Set ROM address, we are overwritting a useless loop function as our hook.
.area 0xA4 ; Set data import limit to 0xA4 bytes
addiu sp, sp, -0x18
sw ra, 0x14 (sp)

Functions in ASM all pretty much start the same way, with a addiu sp, sp [negative immediate] command and a sw ra, [immediate](sp). Since this is ASM and everything has to be difficult, we must allocate our own memory on the stack for any variables we want to preserve between function calls by incrementing the stack pointer, especially the return address which allows the program to return to whichever function called the function we’re currently executing. When we use a command like sw ra, 0x14 (sp) that has a register in parentheses, we are using the immediate as an offset to that register, so this saves the return address 0x14 half-bytes (20 in base ten) after the stack pointer’s memory address. This way we’ll be able to retrieve it later. The “.area” compiler directive is not strictly necessary, but it does help prevent us from unknowingly overriding key code and causing crashes, so it’s good practice when using MIPS but won’t translate to actual code. In this case the example tells us that it’s safe to override the first 0xA4 half-bytes (or the first 164, in our familiar base 10) so we’ll prevent anything further from being overwritten.

The end of the function looks somewhat similar:

proc802CB1C0_end:
lw ra, 0x14 (sp)
jr ra
addiu sp, sp, 0x18
.endarea

“[locationName]:” is a MIPS shortcut for giving us quick human-readable locations to jump to so we can end the function early by jumping or branching to proc802CB1C0_end in our function. Functions all end largely the same way with a lw ra, [immediate](sp) which loads the address we saved on the stack earlier, jr ra which jumps to the return address location so we return to our parent function that called us, and a addiu sp, sp, [positive immediate] command that frees up the stack memory we had been hoarding.

Now that that busy work’s out of the way, we can get to the meat of the function:

// Tests if the player is holding down the L button.
.f_testInput BUTTON_L, BUTTON_PRESSED, proc802CB1C0_end

li t0, MARIO_STRUCT
li t1, ACTION_JUMP
sw t1, 0x0C(t0) ; Set mario’s action to jumping.
li t1, 30.0
mtc1 t1, f2
swc1 f2, 0x4C(t0) ; Set mario’s y-speed to be 30.0

The first line is an ARMIPS compiler shortcut that allows us to test if the L button was pressed on this frame, and if not jumps to the proc802CB1C0_end location we put at the end of our function. This acts as a branch that let’s us skip the meat of the function if the player didn’t press L.

The li command stands for “Load Immediate”. The line “li t0, MARIO_STRUCT” loads the immediate defined at the top of the function into register t0. MARIO_STRUCT is the location in memory for Mario’s unique value types: these include active powerups, his current action, and his speeds in various directions. What we want to do is set his current action and his y speed in order to jump. In order to do that, we’ll need a new family of save commands:

sw t1, 0x0C(t0) ; Set mario’s action to jumping.

This stands for “Save Word”, and in ASM a word is a 4 byte value. It takes the first argument register, and saves whatever value it holds to the memory location in the second half of the argument. Since t0 currently hold’s mario’s memory location, using 0x0C(t0) saves the value of ACTION_JUMP to a location 12 bytes into Mario’s memory, which is the location for his current action. We also need to save a positive value to Mario’s y speed in order to make him float. However Mario’s speeds are stored in floating point format. Rather than storing, say, “6” as “6”, it’s stored as “0x40C00000”. So we’ll have to convert and then use a special floating point save command.

li t1, 30.0
mtc1 t1, f2
swc1 f2, 0x4C(t0) ; Set mario’s y-speed to be 30.0

Once we load 30.0 into t1, we’ll use the mtc1 command to convert it into the floating point register, f2. Once it’s in floating point format, swc1 will let us save it to 0x4C bytes offset of Mario’s memory position: this is where the speed variable is stored.

After compiling this into a Super Mario 64 ROM, we have a new ability!

Wonderful!

What I’ve been intent on recreating is this parkour move from Prince of Persia:

Our goal is to make a move that allows Mario to run along a wall a short distance, and to jump off early if the player so chooses. Now, armed with a working knowledge of what all this means, we can start digging! The easiest way to find what we’re looking for is to start with a something useful from the documentation: setting the Wall Collision Triangle 0x8033B1D0, a reference to the wall geometry Mario is currently touching. Remember, we’re making a wall running function so walls will be pretty important to us! So, we’ll set a break point (see the center of the debugger window) for WRITE at 0x8033B1D0 to find all the places that care about our wall collision.

Functions are called with the JAL command, and this gives us most of what we need to know to start navigating through the code to find region of interest. Step into JAL functions to see what they do, return to parent functions to see who called us, and see what changes and when these functions are called to find out what they do. This is how the perpendicular wall collision test above was found.

A wallrun will have a lot of small subtasks in it: keeping mario aloft while he’s wall running, allowing him to jump off the wall into a jumping state, rotating him along the angle of the wall, keeping him adjacent to the wall while running, and determining what speeds he should have for all of these movements. In the end, it might look something like this!

That’s some serious air time!

Now that I’ve finished The Sexy Brutale, like to talk about my thoughts on the game, what my expectations were met with, and where schedule design could go on the future.

But before that, I want to say that the game was a success and you should consider buying it! The gaudily styled art is quite fantastic, being holistically cohesive and well populated, and is complimented by the bouncy sound track you can’t help but move along to. It uses mechanics you won’t often find elsewhere, and deals maturely with dark themes like gambling addiction (which should come as no surprise in a game set in a casino mansion). The rest of this article will deal with some spoilers, so if you want time to finish this 9 hour game, this is your exit!

Back? Still here? Either way, let’s dive in.

As stated earlier, The Sexy Brutale has few main mechanics that serve to interact with characters on their schedules. These are, basically: to observe NPCs, and to manipulate objects that NPCs interact with on the course of their schedule. This manipulation mostly involves set elements or the use of objects in your inventory.

Point and Click Done Right

First, I want to talk about what this game did well. Mechanically, the game is simple but offers some variety in how you can approach problems. This is a game primarily about observing non-player characters, and you have 4 ways to do so: by peeking through keyholes, listening at doors, hiding in the room, and observing from another floor (except in the bell tower). They have their pluses and minuses: peeking has a vision cone that may conceal the location and identity of some speakers, listening reveals all speakers’ locations but not their identity, hiding in the room can only be done before other characters enter, and observing from requires you to be far away and at times have no good way of reaching the people in a conversation and following them.

Certain points in the game are gated expertly. The tutorial segment for example, is one of the most elegant I have played in years. The game introduces piece by piece the most essential elements of the game: following characters, observing how they are killed, and intervening to stop it by manipulating items and the environment. Although you watch the same scene of a character getting murdered 3 times, each time feels markedly different: the first is a new experience, the second is a surprise as they game restarted the day for you, and the player can prevent the NPC’s death on the third sequence.

Room For Improvement

However, I think some facets of the game could be improved to provide a better experience. For example, the player’s method of observation is almost not a choice. Hiding in the room is almost always the ideal option should it be available: if you are tailing an NPC you will catch up with them more quickly and you have unlimited hearing and vision within the room. Peeking through a keyhole is superior to listening since you can almost always see who is talking (oddly enough the one exception I can think of is in the introduction). The game provides some information that is hidden unless the player is using the improved listening power, but since you can do this while peeking even this is not a reason to listen at doorways instead. The one time a player would be inclined to listen is at green doors (which have no keyhole) but strangely these doors never conceal conversations with any real information. These mechanics could have been explored by requiring the player to figure out the identity of NPCs they can only listen to or NPCs they can hear but can’t see through keyholes, and by making the choice of which door they listen or peek from matter. Additionally, observing NPCs is much easier than it could have otherwise been: there are few puzzles that involve making an unobservable room observable.

While in some ways the gating helps the player learn the game, in other ways it felt limiting and artificial. Rather than be tools in your arsenal of skills, many abilities the player gains are simply upgrades and may not even recontextualize their environment. For example, the second ability is the ability to listen better at doors by holding the spacebar. Not only is there not a reason to listen better all the time, but the player can easily have gotten that far in the game without having ever seen a conversation that needed additional scrutiny.

One design choice that I’m not particularly a fan of is the total inability to interact with characters in the same room. You can’t speak to characters, ask them questions, or show them items. This feels especially odd as every character is surprised or even delighted as they recognize the player character, Lafcadio, after you save them. It limits the amount of information that can be dispensed to the player and the ways it can be given, and feels quite odd as the characters you attempt to save essentially try to kill you as you walk into the room.

Puzzle Design (puzzle spoilers ahead)

For many games like The Sexy Brutale, this is what makes or breaks the game. TSB has some hits and some misses.

One issue with a game about observing characters’ schedules is evading the use of expository dialogue. Many times in the game, NPCs will simply say things that are almost directly for the player to solve a puzzle, rather than being tied into the world. In the 5th puzzle, the player is privy to information by listening to these two goons, who discuss the unlocking mechanism for a lethal trap:

In the context of the conversation, there’s little reason to believe the other goon wouldn’t know this. This solution is then fed to the player, making its execution a formality, and a slow one at that as this conversation occurs inconveniently before the 8 o’clock mark which the player can effectively start the day at.

Compare this to the far better 4th puzzle, in which the player must trap a nefarious musician in a room to save his unwary victim. If he begins his recital with his victim, she will die. However, when the player observes him rehearsing beforehand, something happens:

The musician hears an obnoxious record player 2 rooms away, and goes to investigate so he can turn the darn thing off. Upon getting there he confiscates the record and returns to his dastardly business. After seeing this the first time, the player can take advantage of their knowledge: another record player lies nearby in a closet that can be locked from the outside, and further exploration reveals the treble-clef on top of the piano that can lock the closet from the outside! If the player swaps the record before the villain investigates, he will wander into the closet allowing the player to grab the key, lock him in, and save the girl. What makes this better is that the player isn’t just told what to do: they have to figure it out on their own, and this “ah ha!” moment is the best kind of satisfaction in puzzle design. I should note that for some reason, the piano player can only hear the obnoxious record at the same specific time on each day, despite the fact that the closet shares a wall with the piano room, and that he can even walk into the room with the still-playing record in its closet and not observe it.

Finally, I think there was room for puzzles that really pushed the player’s knowledge of the environment and schedules, but I don’t feel like these puzzles were present. Puzzles are largely contained in small subsections of the mansion and require no interaction with previously explored areas. Only one puzzle toward the end of the game really takes place over very many sections of the house, after which The Sexy Brutale relaxes into a more narrative heavy end game (with a strong pay-off). Many puzzles in the game proudly announce their failure state to the entire mansion: a gunshot herald’s Sixpence’s death, the lights short as Redd is electrocuted, and so on. This information, while well delivered, serves no gameplay purpose as one can only recognize these events after experiencing them, and there is no need to plan a route to save multiple (or all) guests: the game even showed this happening in the end sequence, to my dismay.

All in all, I think The Sexy Brutale introduced some cool new ideas into schedule based games, and that any game seeking to deliver on similar mechanics would to well to see what The Sexy Brutale has to offer. In particular I think such games would to well to explore the mechanical affordances of this game’s spying mechanics, and to expect more extensive deduction on the part of the player.

But does that have to be true? It certainly has merit: games are uniquely situated to deliver powerful and engrossing first person experiences. But in the real world, we are certainly not the protagonist of other people’s stories, and others have lives just as rich as ours. So could it be interesting for a game to put the player in the backseat to the characters in the story, and to be able to really explore characters’ lives and relationships?

Several games accomplish this through the use of a schedule: non-player characters (NPCs) will have their own routines they perform, characters with whom they are friendly or antagonistic, and can be affected by the player only through some knowledge of their habits. They will have a set and static schedule that determines where they go, who they talk to, different ways of interacting with the player at different times, and usually, ways in which their schedule can be influenced by the player.

The Colonel’s Bequest

The first game I want to talk about is The Colonel’s Bequest, a murder mystery game set in an island mansion off the coast of New Orleans in the style of Agatha Christie’s And Then There Were None. As this is a murder mystery, there are in fact a series of dastardly murders! It’s your job to get to the bottom of things, and being a text parser game you’re afforded quite a lot of ways to do so with over 23 verbs. There are however a few main mechanics you’ll be relying on for gathering clues and information to figure out whodunit.

Time System & Recursion: The game is partitioned into 8 acts, each having 4 major events. Act I starts at 7 p.m., and each major event will advance the clock by 15 minutes, beginning Act II at 8 p.m. when all events have been witnessed, and so on. Each Act has it’s own game state with characters residing in different rooms, conversing with different characters, having different moods, and in some cases performing a series of consecutive actions.

In order to fully explore the game, the player is given 2 mechanics for going back to past events. The first, which The Colonel’s Bequest and many games like it use, is the ability to at any time virtually without exception can save your game, or reload to any such save. This allows you to quickly put the game down and return to where you were, to recover from immediate mistakes, and to go back and re-explore earlier parts of the game. Unfortunately this recursion causes players to lose in-game progress, even though they gain knowledge of the game. As this game is meant to be played through multiple times, it also expects that players will fail to collect all the evidence. Fortunately, the game provides players with a useful way to do better on their future playthroughs, by showing the notes their character took during the game and informing them of holes in their observations.

This mechanic is great, and it makes the game far more playable. There are many different categories players may have missed points in, and many of these holes provide nudges in the right direction. Didn’t examine things closely? Try using your lens more. Failed to discover a religious artifact? Maybe it’s near the chapel. Didn’t discover characters with a gambling habit? Maybe you need to ask about them, or observe them more closely. The game doesn’t strictly say these things but rather leaves it up to the player to feel good about deducing it themselves, although some categories are more cryptic than others.

Spying: Characters are seen in major events going about their schedule: moving between rooms, talking to other characters, or even just being by themselves. However, many times they will be in a personal discussion and loathe to continue while you remain in the room. Being the questionably ethical gumshoe you are, you can spy on them unawares! In fact, the house contains a series of hidden rooms from which secrets can be learned, most of which flesh out antagonisms between characters, but some of which reveal surprising secrets.

Unfortunately, many of these secrets do not inform your gameplay. Spying will not tell you where secret areas are. It will not tell you about the hidden treasure on the island, or how to find it. They are entirely narrative, teaching you about the different characters and their relationships so you can piece together the story, and giving you points for acquiring the extra information. This can however be used in interrogation.

Interrogation: Everyone on the island has a different perspective everyone else. To one person Rudy might be a loyal brother, to another a dangerous man with a gambling addiction. You can ask each person about each of the 10 other family or staff, different parts of the estate, items in your inventory, the former owners of the estate, or even groups of other characters, in addition to telling people about what you’ve discovered. As if that weren’t enough, characters responses will change as the night goes on, and as they become friendlier or more hostile towards you. The game has a ton of dialogue, and if you know what questions to ask you can find out a good deal about the game and its world.

Interrogation has a bit more impact on gameplay than spying does. This is the only way to discover important information like who else is using the hidden passages. Other dialogue clues you in to extra objectives, in addition to serving narrative purposes like establishing motives. Understandably there is some redundancy in characters responses, which is good: being required to exhaustively ask each character about each topic each act would be combinatorically explosive. Strangely, the games points based system will reward you very little for interrogating guests. Oh well.

Analysis: So how are all these options, mechanically? Saving and loading allows players to effortlessly jump around the course of the evening provided they’ve saved responsibly, however they unpleasantly forfeit all progress except for the knowledge they as a player have gained. Being able to covertly spy on conversations to gain extra information is good, however the player can go through the entire game without discovering these passages at all (after which the notebook review will explicitly state that there are hidden passages), and spying or the way you spy is never a real choice: it is always preferable to spy covertly than to be seen. There is one instance where the player can shepherd NPCs to a spyable location, but this is underused. The ability to interrogate on any topic has a lot of potential, but pruning topics NPCs are disinterested in from the tree of possible queries could make interrogating less tedious. However it does a good job of informing the player about the world, should they ask the right questions. The exploration relies a lot on the player’s willingness to explore and retraverse the same areas of the estate in later acts, which is somewhat mitigated by player knowledge of future events: if someone’s stabbed in the back by a dagger, there’s only a few places that dagger could have come from. If a distinctive boot print shows up, the player may want to pay more attention to characters with boots, or try to find a boot with a matching insignia. Unfortunately, few of these mechanics afford the player ways to truly interact with the NPCs at times making it feel less like a game and more like a story. The biggest exception is the character you can befriend, who will give you important clues and information thereafter. On the whole the game presents some cool ideas, but often has barriers in usability.

Majora’s Mask

Probably the first thing people know about Majora’s Mask is that it’s a real time action game in the Legend of Zelda Series, making its presence in a discussion about narrative a bit odd. While the game has a lot going on outside of its largely optional schedule-based side quests, I’m going to be talking about the game and its mechanics in the context of the schedule-based NPCs and their daily lives.

For those familiar with the game, most of this analusis will be with the Kafei and Anju (K&A) quest which uses the scheduling system to its fullest.

Time System & Recursion: The hook of Majora’s Mask is simple: a villain has enchanted the moon to crash into world in 3 days, and you can travel back in time to the start of this cycle as many times as it takes to figure out how to stop it. And every time you return, the game saves. Already this is a big improvement over the recursion in The Colonel’s Bequest, as you don’t lose in game progress for returning to an earlier point in the schedule. Majora’s Mask of course is different in that you cannot complete the game without returning to the start of the cycle multiple times (even in speed runs). Additionally, the passage of time is continuous and not discreet: it does not depend on player actions and slowly progresses. The player can influence time by slowing it down(by a factor of 3 in some versions), returning its flow to normal, or immediately progressing to the next 1/6 mark of the cycle.

Since the player saves by travelling back in time and can do so at will, he or she can save at almost any point. While doing so, the player will keep all non-consumable items, allowing important progress to be saved. This does however eliminate any partial progress the player might have had in a quest, since it restarts the whole thing over.

Instead of telling the player what they missed, the game will tell the player what they have yet to accomplish, with an item called “The Bomber’s Notebook”. In it each quest has its own line, as well as what time events in that quest take place, but what those events are is only revealed upon completing them. Players can see clearly and quickly if they’ve failed to meet an objective in a particular quest and don’t have to commit to it further until they’ve gone back in time. The system allows players to plan routes around the game world to satisfy as many quests as possible in one cycle, often knowing they have to be at a certain place at a certain time. This generosity comes at the expense of opportunities for deduction on the part of the player, who is able to treat the scheduling system as more of an optimization puzzle than a mystery to be solved.

Character Interaction: While you cannot ask questions per se, you have 4 different ways to interact with characters. First, the default interaction, you receive the response the character has for that time in the cycle. Characters tend to be more focused on their everyday life early in the cycle, and scared or defeated when the moon looms large over the game world on the third day. You can also speak to characters with different masks equipped. Wearing a mask of a character’s face introduces them as a topic of conversation, and if the mask is magical you may be entirely mistaken for a different character. The last way to speak to characters is by presenting items, almost exclusively done in the K&A quest. Finally, performing certain other in-game tasks, often in the vicinity of an NPC, will change characters’ opinions of Link (the player character) and will often reward him.

Since the Legend of Zelda’s narrative is meant to be incidental to its action, the systems for interacting with NPCs is not so robust. Two advantages it has over the Colonel’s Bequest however is that characters are much more likely to respond to your in-game actions, and that characters’ timelines can be altered quite a bit more.

Analysis: While the Colonel’s Bequest was very observation based, Majora’s Mask is very quest or action based. Design decisions in the scheduling system and its quests are made that keep the player moving and rarely attempt to stump the player. Many quests require the player to simply have access to a certain area or have a certain item than to really understand where NPCs are at what times or what their motivations are. What the game does bring to the table are good mechanics for going back to the start of the schedule as well as tracking or preserving progress. The change from the player controlled time system is largely mitigated by the player’s ability to control time so much.

The Sexy Brutale

Having come out in 2017, The Sexy Brutale is a modern take on what interesting gameplay can be created through NPC schedules. Players are trapped in an exotic mansion and are tasked with saving the lives of the other guests who are each killed in their own way each day, often by the malicious staff. Coincidentally, or perhaps as a deliberate reference to Majora’s Mask, nearly every character wears a mask which can be removed from guests only by saving their lives. Each time a character is saved a new ability is granted to the player, or old abilities are enhanced.

NOTE: While I’ve yet to finish this game, I’ve played 3 of 8 or so hours of it and feel I have a good enough grasp of the mechanics. I’ll edit this post if any of my opinions change later.
EDIT: I think there’s enough to talk about that this will be another post entirely.

Unlike both previous games, in the Sexy Brutale there is very little interaction with other characters: this is because upon entering a room with any other character a threatening sequence starts wherein time stops and the player is chased by the masks of other characters until the player either exits the room or is killed. NPCs then continue with their day as though nothing happened.

Time System & Recursion: Like Majora’s Mask, it uses a time-recurring system that allows the player to return to the start of a time window at will, at which point the game will save. Similarly, the player will lose all items except the one that permits the aforementioned ability. Additionally, whenever the player encounters a clock they can do any of three things: advance to the end of the 1st third of the day, advance to the end of the 2nd third of the day, or set that location as the one at which he or she restarts the day.

As mentioned before The Sexy Brutale employs a saving and time traveling feature nearly identical to that of Majora’s Mask. Whereas each cycle in Majora’s Mask lasts for 3 in-game days that can last hours in real time, a full cycle in this game lasts mere minutes. As such there’s a much lesser penalty for mistakes since there’s only so much a player can accomplish in a few minutes’ time.

Like Majora’s Mask, The Sexy Brutale keeps a quest log of the characters you have saved and tasks you have yet to accomplish. Dissimilarly, it prompts you with a small subset of objectives and gates you from further ones. This keeps the player focused, but limits exploration.

Spying: This set of mechanics are at the core of the game, and are far more fleshed out than the simple cutscenes in the Colonel’s Bequest. Players can spy in 1 of 2 ways: by sight or by sound. When a player approaches a door or other window into a room he or she is granted a cone of vision into that room which can by slightly rotated, allowing a limited perception that is different for each portal into the room, and is privy to any conversations taking place. If the player chooses instead to simply listen at a door, he or she hears the same conversations and is informed of the exact origin of all sounds, but not who or what they originated from.

Analysis: So far, there aren’t a whole lot of ways to interact in this game, making it feel a lot more like a puzzle game than very involved with characters. Even Majora’s Mask, which was not based primarily around it’s schedule system, allowed the player to feel much more involved with characters primarily because it does not prevent face-to-face interaction with NPCs. I love the spying system the game presents, and unlike teh colonel’s bequest it can modify your access to the game world by giving you access to know areas, by learning a code combination for example. I unfortunately have not come across an instance where listening was the superior option to peeking, or where the particular door you choose to view from was a meaningful gameplay decision as NPCs tend to interact with each other and the environment far from doors. Additionally, a lot of the puzzles seem to be about acquiring the new item in the new area and racing to interact with someone before their death, rather than employing learned information like guards’ schedules or characters’ tendancies.

I’m also not a fan of the way the game gates the player so heavily. I constantly find myself wishing I had more freedom to explore the world only to be seemingly arbitrarily held back. For example, one of the upgrades the player gets is an improvement to your hearing: some conversations simply cannot be heard beforehand and it feels like this upgrading mechanic could have been taken further than it was. The exception is that the gating and pacing in the tutorial is truly fantastic. It teaches you very quickly how you can interact in the game and all the basic rules you need to know in a very timely and intuitive fashion.

Conclusion: So if I were to make a game with some of these mechanics, which ones would I use? As I’m a fan of interrogating characters to find out more about the world, I would choose a console friendly approach that still allows for significant questioning. The text-only system in the Colonel’s Bequest, while giving you great freedom, could be largely accomplished with a term-based system used in many games that allows you to select a topic to talk about. As many characters understandably have limited expertise or interest, I believe these terms could be grouped by subject in order to remove an entire category from conversation options should the NPC not care about a particular subject (for example science, sports, or religion).

I think the spying system in The Sexy Brutale, while innovative, could be taken further to offer more varied gameplay. For example, asking players to find new spying points to verify the identity of a speaker in some conversation or modifying the room beforehand to change how observation can be conducted.

I’m also interested in the discreet time system the Colonel’s Bequest uses, which makes the action very player driven. One shortcoming of the system is that the player knows there are only so many things to encounter during an hour, but this can be subverted by having, say, the first 4 of 6 possible events advance the hour, to keep the player guessing as to what’s out there. As for recurring the day, it seems good gameplay to let the player save and restart the day or cycle at will while keeping progress. I think an excellent hook for this sort of game could be having a villain that also travels through the same day, especially one that asks other NPCs different favors to introduce confounding variations in day-to-day play.

If you’ve gotten this far, thanks for reading! I think this kind of narrative structure has a lot of potential left in games, and I hope we get to see more of it. Let me know of any other examples you can think of that follow this structure, and anything interesting they do! Cheers!