A couple of months back I was approached by Ania Kubów, who has a YouTube channel dedicated to JavaScript tutorials. She wanted me to contribute to a video for FreeCodeCamp showing of the top 20 entries of this years JS13K, by having their devs show and explain some cool bits of code. As Edge Not Found managed to get 2nd place, I figured I should actually record and voice this video myself (something I don’t often do online). My code example is about how I render the same level seemingly infinitely across the screen, which you can find on CodePen here.

My part start at 9:12 in the video, but I’ve also provided a transcript with images of my part in the video below. I hope it is useful to someone!

Introduction

Hello! I’m Tom Hermans, I’m a Dutch developer who also makes video games sometimes, and for this year’s 13K jam I made “Edge Not Found”. It’s a puzzle game in an infinitely repeating world. I really like tile-based box pushing games like Sokoban, and I’ve already made several of them, but this one is probably my most complex one yet. I’ve been sitting on the idea for this game for a while, and the jam was a good opportunity to develop it and design some cool puzzles for it.

So let’s talk about the rendering for a bit. Each frame in the game is drawn using three steps. In the first step I create multiple canvasses that serve as sprites for the various puzzle elements, like walls and boxes. These are drawn using the rough library, which generates nice, hand-drawn looking shapes.
The second step renders the current puzzle state using these sprites, like this, then finally, it’ll draw this level repeatedly to fill up the entire game canvas. I really like the bit of code that handles this, so today, I’ll explain how this infinitely wrapping world works.

For demonstration purposes, I’ve pre-generated a level image from the game instead of generating one from scratch, to keep it simple. Now then, I have isolated the code in this sample. I’ll go over the most important bits, but if you want to toy around with the full thing, you can access this example with this link. So let’s go through it!

Rendering magic

The core of the tiling magic happens here, with the x and y offsets:

These essentially affect how the levels are tiled. For example, if you’ve played the game you know this level can’t be solved, since the crate can’t get to the goal:

But if we change the y offset to 2, the level becomes a straight line, and the puzzle becomes solvable. It’s kinda complicated, but it is used in lots of tricky puzzles!

Next, we calculate how much levels we can fit onto the screen. The clipoffset here adds a small margin to the level border. But it also shows that the code works by putting it to a negative value*, then if I resize the screen you can see that levels are no longer drawn near the border of the screen. This makes sure that nothing will be drawn if it nearly or completely invisible:

Finally, a nested FOR loop actually draws the levels. Note that levels further away from the center will get more transparent. So if I zoom out all the way, you can see it will go on for a while, but eventually the wrapping will no longer be visible!

When drawing the image with an offset defined, we shift the image on the grid. So, if I enable the coordinates display, you can see that the image also shifts two tiles down for each step on the x axis, and that’s due to the levelOffsetY I set earlier:

Conclusion

And that is it! Once again, you can view this code snippet here. Do consider playing Edge Not Found first if you haven’t, so you can learn how this level wrapping is used for tricky puzzles.
So, I hope this inspired you to make your own infinite worlds! If you liked this, then you can find me as Auroriax on Twitter for more of my things, and if you look that name up on GitHub you should also be able to find the full source code of the game. Bye, and thanks for watching!

For this, it’s important that you ice your projects correctly. Icing is similar to making a backup of a project (also super important!) but it involves more than that. When you ice a project, you should not only record it’s current state, but it’s also about ensuring that you can access that project multiple years in the future, and what your intentions were when you last worked on it. Aside from doing obvious things like commenting your code, some special considerations must be made if you want to ice your project in such a way that you can still get started with it years into the future. That is what this post is about. I have six thoughts I want to share.

1) Choose stable development technology

Technology can change a lot in a couple of years. Not only has this to do with the continued improvement of technology, but also the tug-of-war that the platform holders are playing with other platforms and developers. They can change the rules of the game at any moment, with or without reason. The only way you can get around this is to pick a technology that is likely to be around in the future.

This can be very hard to estimate, but it’s personally why I’m now mostly making browser games, since the tech has been around for a while and I expect games to stay mostly compatible with future browsers. If the technology is open source, or if the company keeps offering all older versions of their technology, it’s a good sign that you’ll probably be able to keep opening your project files for at least a couple of years into the future.

2) Document the most important things

Even then, you must record how to do stuff. Any documentation or help on the internet can vanish or drown at any moment. (If you have a page that you must preserve, consider adding it to the Internet Archive. That way, everyone can access it, even after the original goes down.) This is especially important if you work with technology that has been or will soon be deprecated.

The most important one is to keep a version of the technology around (for example, the installer package for a game engine). Save it together with the project if you can. Aside from that, you should keep a basic instruction for how to set up and compile a project. In this readme, record which version of specific programs you’re using, a step-by-step guide in how to set up the project on a fresh computer, and link other important documentation you’ve made (such as planning or design docs).

And if you have passwords for something (like virtual machines or Android keystores), don’t forget to record those too. This is also important for games that are already released: ask yourself, what should I absolutely record in case I want to update the game in the future?

3) Ice every single project

If you drop a project, it’s hard to say if you’ll ever gain the motivation to work on it again, or that it is simply left in the dust forever. On one hand, you’ll have to put in some effort to preserve a project that you’ve basically given up on, which you might not have the motivation for. But, realizing that you want to revive a project, but coming back to the code it’s a mess? Or it completely corrupted in the meantime? That will very likely dim any motivation you might have gained during your break.

Therefore, don’t be selective about which projects to ice. Just ice ‘m all. 15 minute prototypes to near-finished abandoned projects, you should treat them all the same. You never know when you might need it. (This could get messy though, we’ll talk about that in a bit: see point 5.)

4) Ice the latest version

If you’re a bit like me, you might take multiple breaks from a single project. Sometimes, I’m only able to recover an earlier version that I remember last working on. For example, when in 2020 I defrost a project I last worked on in 2019, I might only be able to find the older version from 2018 instead. This puts you in a tough dilemma: will I recreate the functionality from 2019? Or do I push the project in a different direction instead using the 2018 code? Or do I start over entirely? Or keep looking for the latest version?

Just this dilemma alone might cause you to give up defrosting the project completely. So make sure that when you notice a waning interest, you store the newer version of the project, preferably in the same place that the older version is in, and clearly label it with a version or a date so you can’t mix them up. (Don’t delete the older version though, see point 5.)

5) Don’t bury it

You might have so many unfinished projects across different technologies that it becomes a mess to recover one, should time ever come to revive it. Or you might want to be able to steal some specific functionality, a specific part of a prototype you want to reuse. Organization is key here: how would my future self attempt to recover this project? Try to be consistent with folder structures, file names, and where you store projects and assets.

As for where to save the project for recovery, this is a tricky one. Since your project will likely be offline (on your local file system), storing a copy in an online cloud service makes the most sense since it doubles as a backup. But will the online service you use for this still be around next year? What about the next five years? Finding a reliable permanent storage location is really really tricky in a world where technology is constantly changing.

As a last resort, you could remove projects to clean things up, but my recommendation here is actually to never manually delete any project at all, if this is feasible for you. For all assets there’s a non-zero chance you might want to recover it in the future. I might be especially careful in this area, but do consider asking yourself if you’ll absolutely might never need the project in the future, before deleting it permanently.

6) Or release it anyway

In software a project is never done: sometimes the team runs out of money or time and is launched into the world regardless of its completion state. If a project is unfinished, you can always throw it on the web with a disclaimer that it’s unfinished, and see what happens. If it’s clearly unfinished, I’d add a disclaimer that it’s a prototype. This takes a certain amount of bravery, but people might like it despite the fact that it’s unfinished (and of course, there are some people who like playing unfinished games for what they are).

But if it is already in some kind of playable state, you could consider releasing it as a normal game with no disclaimers at all. Now, at least you have some documentation (a project page) and an executable of the project in an easily accessible location. Finally, consider releasing the source project: this backups the source code, and in the rare case someone else want to pick up the project, they can do so (if you want this and give the project an open source license).

Final Words: What I use

I use Writer and Github Gist for single text documents. Sometimes I also drop text files in Trello cards on my project’s boards. For some of my games the source code fits in a single text file, so this is nice for those. Gist can also do hosting & version history for text files.

Github and Bitbucket are used to access to git and store larger projects. Git does a lot of things, but I mostly use it to keep projects synced between my various computers. But it’s also a version system, so you have backups for past versions of your project. There’s a learning curve, but it’s definitely worth investigating and goes a long way into solving the problems above.

I hope this post was helpful!

So I participated in js13k again this year, this time sticking to my cards better and decided to make an eye- as much as a brain-bending puzzle game called Edge Not Found. After working for almost a year in TypeScript (and Canvas) for my job, I feel I have a lot more experience working with the browser, along with the things I’ve learned from my entry last year. So here’s another larger-than-13kb postmortem about a smallen-than-13kb game.

js13k last year was the most fun I’ve had with a game jam. There’s a lot of activity from devs on Twitter (though not overwhelmingly so), the month-long deadline is very relaxed compared to some other game jams (you’ll finish on time even if you contribute just half a kilobyte per day!), and there are simply some amazing technical marvels that people create even despite all these limitations.

Last year I wanted to try out the Zdog library, this time my choice fell on rough.js, which creates seemingly hand-drawn versions of geometrical shapes like cubes and circles. I stumbled upon a blog post that explained how this effect was achieved, which made me want to try it out. Next to that, I’ve been working on a mini JS framework called Tomato that supported timing, hitbox and input management, which I wanted (and did) improve during the jam. And programming in JavaScript with a live reload plug-in is absolutely a blast thanks to the blazingly fast iteration time.

And, of course, a seed for a game idea. I’ve made a couple Sokoban variants before, and my next idea was to have the level continue infinitely into all directions. A small spoiler warning, though: I’ll vaguely describe some of the puzzle mechanics (though no puzzle solutions!) in this postmortem, so you might want to play the game a bit before reading on.

Programming

A level in this game is defined with a 2D array to set up the grid and some metadata such as the level name, but also shift offsets that are used for later levels. I think undo is the most important functionality any puzzle game should support, and as such I built the game up in a way where the game & rendering logic are separated to make that possible.

The rectangular border in the middle of the screen indicates the only part of the level that actually exists. If you walk through the border, as far as the level state is concerned, you’ve wrapped to the other side of the level. There’s some math to decide where you should end up if the level is “shifted” (the level grid is not uniformly aligned).

One thing I attempted to implement was pathfinding. Lately, a number of Sokoban-style puzzle games have popped up that allow players to click or tap a location and have the character figure out how to walk over there. I really wanted to have this feature, but A* pathfinding was not intended for infinite grids. I really want to implement this for my next puzzle game, though.

Optimization

Make no mistake: even code that fits on a floppy disk can be incredibly slow when drawing a lot of things to the screen. At first I drew a rough.js primitive for every block on the screen, which is where this limitation became evident. Then, I drew the shapes to a level canvas, which is then drawn as an image and repeated across the screen. This was better, but still slow on levels with a lot of objects. So then I also drew all individual objects to their own canvases, drew those onto the level, then drew that repeatedly on the main canvas. Also, the game now attempts to skip rendering when nothing changes, using the object-level-main canvas technique described above, and that caused a more significant improvement than I originally expected.

A nice benefit is that all of this makes it really easy to support multiple color palettes, too. I made a couple of nice ones, including one based on Okinaki (my favorite color theme in N++) and BackFlipped, a theme with the color palette from my previous entry.

I made a linter for my entry last year, but I expanded it for this game, and mostly re-purposed it as a way to put multiple JavaScript files in a single file to minify it elsewhere, Google Closure Compiler in my case. Last year I had a lot of trouble with the Closure Compiler, but because of my choices of libraries combined with a better coding style, it worked with minimal hiccups this time around, allowing for a bit more content. Ultimately, I was able to minify around 79kb of files to just below 13kb zipped.

Level design

Making puzzles for this game took a lot of iteration, but overall I’m really happy with the level of puzzle quality in Edge Not Found. I iterated a lot and kept the very best levels, and made sure to enforce the intended solution. In world 1 and 2 you’re still getting used to the wrapping world and the puzzles are easy: the wrapped grid makes sure that the possibility space is bigger than in an ordinary version of Sokoban because it’s easier to retrieve blocks from tight corners in this game. But everything from 300 onward showcases very interesting properties of the system that are really fun and mind-bending to discover, and in some cases allow for very hard puzzles. I am still a bit divided on the new mechanic introduced in the final world, which I would preferably have introduced earlier, but since it mostly exists to compliment the other mechanics in the game, it does make for a fitting finale of the game together with level 404.

I especially love how the level select came together. Initially, I was planning for the [Esc] menu to be used for navigate between levels, but procrastination hit me hard. I ended up implementing it as a regular level instead, allowing me more control over in which order the player could play the levels.

Initially, all levels could be accessed at the start of the game. I decided to gate it slightly, to make for a smoother difficulty curve and a better sense of progression. You don’t have to beat all of the levels to continue, since some of them are really hard and I want players to have a realistic chance to unlock level 404 and finish the game. The main problem that spawned out of this is that the level select would become so big, it would no longer fit on the screen. That’s how I ended up with the current tight design, which already teases the mechanics of level 200 a little bit if you pay attention.

Conclusion

I had a blast making this game, and the reception also seems a lot better than for my entry last year. It was a great test run for my mini framework Tomato, and I worked out a lot of the kinks for the first game using it. I’m certainly looking forward to doing more projects like Edge Not Found, and I’m really curious to how it will do in the js13k voting.

If you have some time and are now really excited about playing the game, you can play either the contest submission or the itch version! Thank you for reading.

Yes! Fake Illusions (the game I’ve spent a year and a half developing, and will probably continue to work on for a bit) is now out on both Steam and itch. It’s great to finally have it out of the door, and I’m curious about how it will perform on both platforms.

It has been a little bit of final sprint to get to this point, but the application is nice and stable now. I feel it’s the first game that I’ve made that I feel comfortable slapping a price tag on. So we’ll see how it goes! There’s also a new launch trailer to go along with it.

If you want to request a review copy or want to use the game for educational purposes, feel free to reach out for a free copy: my contact details are on the top of this page.

Thank you and enjoy!

There have been a lot of games about optical illusions recently, but most of these have focused around impossible geometry in Esher-esque environments. However, many more interesting visual phenomenons are still unexplored in games. I had the idea of hiding “fake” optical illusions inside real ones, and having the player point out the cheater. After an initial prototype with a few illusions, I’ve spent the last year and a half working on expanding this idea, and I’m currently preparing it to launch on Steam soon!

Because the game idea is so unique and visual-focused, it runs at a high risk of being very inaccessible to play, for example for people with bad eyesight, colorblindness, or other handicaps. I have some experience with this subject when designing the accessible precision platformer Mobility, so I wanted to ensure the same accessibility for this game, even though the two game ideas are wildly different. Today, I’d like to run through my design choices for keeping Fake Illusions accessible while still embracing minimalism and surrealism.

Simplicity

Fake Illusions features very little text: the logo, an epilepsy warning and the credits. This makes a couple of things more difficult to design for me (mostly the tutorial and menus), but it generally pays off since players are not required to speak a certain language to play. Also, you don’t have to worry as much about font sizes & contrast, but just to be sure, all text in the game is always rather large and has an outline.

Similarly, the game can be controlled completely with just the mouse and left mouse button, with Escape being the only other recognized button. The simplicity of the controls allows players to focus on the game instead of on the input methods.

The game features almost no dexterity elements—quite the opposite, the game rewards concentration and thoughtful answers instead of brute-force or quick reactions. The number next to each illusion allow multiple players to discuss the puzzle more easily. Any time the player changes a setting or makes progress, the game autosaves so the player can quit at any time without losing progress.

Most of these features were implemented and standardized rather early, and as such, all of these seemingly small design choices really bring accessibility into the core of the game’s design.

Colors

Most optical illusions require the maximum amount of contrast you can get to achieve the strongest effect, meaning you’re often required to use black or white. I expanded this monochrome style even to illusions that do not necessarily require it, making the game as colorblind friendly as it can be with this gameplay. In the rare case that an illusion type still trips someone up, the player can simply skip the illusion (we’ll get to this later) or change the settings.

Sometimes the game breaks from this style for contrast colors: crosses are red while check marks are green. There’s also a single case where an illusion in the game does not work in monochrome, and keeps its original colors. Altogether, this allows for an art style that looks minimalist and uses a lot of primitive shapes, which has the added side effect of keeping the scope of the artwork small enough so I can make all of the game’s art assets by myself.

Difficulty

Since this game is very focused on spotting visuals, you have to take into account that not everybody’s eyes or screens are equal.

One of the playable illusions in the game is the Hermann Grid, where players have to find an actual gray square in the intersections between larger black squares. When I was playtesting the game during a network lunch, I noticed that the “faker” gray square was not visible on this screen. Apparently, the monitor ignored the very light shade of gray and turned it into full white. For this reason, the brightness slider was very important to add.

This game has a difficulty slider that indicates how much the faker is allowed to stand out. At the default level it offers a fair challenge, but it can be set much harder but also much easier. The range on the slider is actually pretty wide, with the extremes making the puzzles either trivial or nearly impossible, to suit every type of player. I think this offers a much more dynamic control over difficulty compared to Easy/Medium/Hard settings that are currently the standard in many games. The slider appears in the settings menu, but also in-between levels while playing the illusion.

If the player changes the difficulty beyond a certain point, a smiley (or frowny) in the interface indicates this. This is mostly to make sure that the player knows it’s a globally applied setting and to remember them they’ve set it to a non-default value, and that they can follow a breadcrumb trail to the settings menu where they can adjust it back.

Progression

To complete Fake Illusions, you only need to beat around half of its content. Meaning you don’t have to play every illusion if you don’t want to, for whatever reason.

The game encourages the player to take breaks, or at the very least, switch between illusions from time to time. There’s an intermission screen each time the player beats a level of the illusion, and if the player has unlocked something new in the meantime, an exclamation mark is displayed on the “back to menu” button. Then the same exclamation mark is displayed on the thing the player unlocked in the level select.

At first the progression worked that only a fully completed illusion would unlock others. But I changed it so that every completed level (each illusion has around 5) would add up to unlock things. Players can still beat everything if they want, but it gives those who might get stuck more freedom to continue towards the end of the game.

As a final detail, the last level in the game is the Shuffle mode, which gives the player hard versions of random illusions. The player will only encounter illusions here if they’ve already beaten the first difficulty of that illusion earlier, to make sure they only get puzzles for which they’ve already been onboarded. It’s a small feature, but one of which I’m certain will ease frustration.

Scaling

One thing Fake Illusions has that not many games do, is having a fully re-scalable window. The game tries it’s best to fit in at a 16:9 resolution, and also fills parts of the window that would normally be outside the 16:9 range. As a result, the game’s graphics fit no matter at which resolution you play.

There’s also a zoom slider, in case you’d prefer to play the game at a different or pixel-perfect zoom level. The slider only appears when the window is larger than its default resolution (which is 1280x720), because the window can also scale a bit smaller than that for smaller windows or screens. (The Steam Hardware Survey is a very good guideline for knowing exactly what kinds of screen widths and other features to support.) I can imagine people will want to set the zoom level low, since they’ll have to move the mouse less, so most of the buttons and hitboxes in this game are quite big to help these players.

Final Words

The final thing that I’d like to talk about, is advertising your accessibility features on your store page.

When looking up info about games I’m interested in, I generally like to know which settings are available in the game so I know how accessible it is and how much I (as a player) am allowed to tweak. But for most games, this info is not readily available, requiring me to dive into reviews or social media to figure out what I can or can’t change.

Screenshot of Fake Illusion’s Steam page.

So if you want to signal that your game was designed to be accessible, please put this info up on the store page, front and center! The Game Accessibility Guidelines also recommend you put this info in an easy-to-find location (preferably also in-game). You cannot make the game accessible for everyone, but at least you can expand the range of people who can play the game, and set the expectations for your users so they know what they can (or cannot) expect.

Thank you for reading, and let’s make all games more accessible!

Learn more

Wordy tutorials need to end. Why Game Designers should take a “Vow of Silence” by Hamish Todd
Game Accessibility Guidelines
Includification by AbleGamers

Since lots of people are currently stuck at home because of the corona virus, and I really wanted to contribute to notGDC this year, I’ve decided to write about something that I wanted to share for a while now: tools to prevent yourself from getting distracted while using a computer.

When using any internet-connected device, the line between exertion and relaxation can blur very quickly—and I can relate. In my case, one time during an internship , I got side tracked and started watching… a Tetris competition. Of course I got caught: that was the moment where it dawned on me that the freedom to get distracted was too much responsibility for me. So I decided to take away some of that freedom, and opted to add measures on my computer to achieve that. I’ve used a lot of productivity tools over the years, so I’d like to share with you what I’ve learned and what worked for me.

Some context, though. I’m 22 years old, lived in a student house for around the past four years, and for the last months I’ve lived in an apartment by myself, working remotely. Most of the recommendations here will be Windows applications or browser extensions. I also have as few apps on my phone as possible to minimize distraction there (a “dumbphone” of sorts).

Some of the methods I’m using might be a little extreme, because I need it to stay sharp and motivated. So you might not be able to use very single tip here, but I still hope these pieces of software and other tips will suit your use cases!

Recommended productivity software

LeechBlock 🔒

LeechBlock is a Firefox extension that blocks off access to sites during scheduled blocks of time. I like this program because there are tons of settings you can tweak. Which means that it might take a while to find a combination of settings that work for you, though!

In my case, it’s pretty strict. I can override it, but the method I’ve set (typing over a random 32-character string before overriding 10 minutes) is annoying enough that I only do it if I really want! I use it to block social media an news sites during work from 9 to 12 and 13 to 17, then lock those again at around 21.

This is the only tool I’ve used that allows me to set it up in such a way that I will play along with the restrictions I’ve set up, yet is just not strict enough that I’ll attempt to bypass those restrictions. That reason alone is why I’ve placed it on top of this list. I recommend it a bunch! (It also has a Chrome version.)

uBlock Origin 🙈

Ads can be pretty distracting, and making yourself invisible on the net might be just what you need to keep focus, especially if your work involves surfing to a whole lot of random sites (like game dev!).

uBlock Origin is the one I recommend, because it will also allow you to manually filter site elements that aren’t ads, if you don’t like those for some reason. For example, I use it to filter cookie permission banners, buttons in menus that I never use, and for some distracting sites I’ve even used it to sabotage site functionality, so that using the site becomes a very annoying.

Max Tabs 📑

Max Tabs is a Firefox extension that limits the amount of tabs you can have opened in a single window at the same time. I use this to make sure I close tabs I don’t need, since mess is usually a main source of distraction for me.

You can set the maximum of tabs yourself. This causes my tabs to be spread out across multiple windows (usually private windows in my case), each window carrying related subjects, which can be closed quickly when I’m done with them. (You could also look at something like Tab Groups if you’re primarily looking to organize your tabs.)

Tools and other tricks

You can use these tricks mostly without installing additional apps on your PC.

Do Not Disturb mode ⛔️

I use this on every device that supports it. On most Android devices, you can indicate a time period in which your phone automatically jumps into a “Do not Disturb” mode. If that doesn’t give you enough control, there are also apps that allow you to automatically toggle things like WiFi or Airplane Mode on and off at certain times, like Timeriffic (although its interface is a bit dated).

Writing down stuff ✏️

When I have a really cool idea, but I can’t act to it right away, it remains in the back of my mind until it’s documented. For solve this, I usually use a Trello board if it’s related to one of my projects, or a physical noteblock if I need to draw out new ideas.

I really like noteblocks, because they allow me to record idea’s when all my devices are off, and make drawings or diagrams that are difficult to create (quickly) on devices. My notebook also has a sleeve which allows me to carry it with one hand and draw with the other, and has a slot to stick a pencil inside, so I have everything I need to make annotations anywhere quickly.

Night light & grayscale display modes 💡

I have a really bad habit of staying up too late behind the computer. The Nightlight feature in Windows 10 helps with this: it filters out the blue light that tells your body you’re looking at the sun. The blue light prevents your body from producing the oxytocin you need to fall asleep, because it makes your brain think the sun is still up. (Twilight on Android serves a similar purpose.)

Similarly, some devices have other options for screen coloring, including a greyscale mode. It looks cool (I sometimes use this option on my Nintendo Switch to turn it into an enormous Game Boy), but it also filters out colors that would normally be eye-catching and thus distracting. Look into the accessibility options on your device to learn more.

User time limits ⏰

The previous night light tip only soothes the problem of late computer work: it doesn’t prevent it. There’s also a setting in Windows 10 that prevent users from logging in during certain periods of time. So if you’re still using your computer when the period goes in, you’ll be able to continue using it, but if you lock it or are otherwise logged out, you can’t get in until the period has passed.

This is the most extreme measure I’m currently using, but it’s also the most difficult one to set up because you’ll need to do it in the Command Prompt. Additionally, you can set up one user account with only your productive stuff installed, and put the rest in another account with a really long password.

Or you can look into T‑Clock, with which you can set alarms and hourly chimes to remind you to take a break.

Know your shortcuts ⌨️

For me, if I can stay in the flow of the work I’m doing, then the chance that I’ll trail off becomes much smaller. I’ll assume you’re already familiar with shortcuts like Ctrl+V and Alt+Tab, so here are some of the lesser known ones that are equally as useful (especially for game devs):

• Windows+D: Show desktop
• Windows+E: Open Windows Explorer
• Alt+F4: Close current window
• F2: Rename file
• Ctrl+Shift+Esc: Open Task Manager (saves you a trip to the Ctrl+Alt+Delete menu!)

Here’s a pretty complete list of shortcuts on Windows. One extra tip: in Windows Explorer, typing “cmd” in the navigation bar will open the command prompt in the current folder. Super useful to get commands running quickly!

Additional tools

Here are some things I’ve used previously but didn’t work for me, but might for you:

RescueTime 📈

RescueTime tracks what kinds of software you use throughout the day. It already knows of most programs which ones are distracting and which ones are productive, and you can adjust this yourself too.

While this tool is great for tracking your behavior, there’s little incentive provided to actually improve this behavior. Still, if you are in the early phases of figuring out which things cost you the most time, RescueTime might be just what you need to analyze it!

Habatica ⚔️

Habatica is a Trello board combined with an RPG. I didn’t like it because it Habatica doesn’t actually track anything: it trusts the user to set all their tasks and habits and report accurately, and you need to play it with multiple people to make any meaningful progression in the RPG bit. There are more gamified tasks lists out there, if that sorta thing motivates you, try out some and see which one works best for you!

Cold Turkey 🦃

Cold Turkey has none of the edge cases that other app blockers might have that will allow you to use blocked stuff while you actually should not be able to. It’s feature set is very similar to LeechBlock, but it runs on your desktop instead It didn’t click with me because their free version is pretty basic. However, it might be just what you need if you often want to manually lock down your computer to get a couple hours of complete focus on work for a nearby deadline or deliverable.

Conclusion

I have used a lot of productivity tools because I know myself all too well, and recognize that I need them to use a computer properly. Hopefully I’ve convinced you to try some of these tools to keep your own distractions at bay! If anything, try out LeechBlock, since it’s generally the most effective tool for me. Thanks for reading, and good luck!

You might also be interested in:

• Nicky Case: Habits I (Tried To) Make in 2018
• AlternativeTo: Apps with ‘Anti Procrastination” feature

Here are some games I liked. Like last year, I just played these games this year, since I don’t really care about their original release date. The order of games is also pretty much “in the order I can think of them”, so take it with a grain of salt. Maybe two.

Here goes!

Sayonara Wild Hearts

This game released on the same day as Untitled Goose Game on the Switch, and as such I was sent into doubt about which game to play first. Untitled Goose Game won that day, but this game kept lingering in the back of my mind. I beat the entirety of the game in one day (which is probably the best way to beat this game), and the music and graphics really evoked an emotion of flow in me that’s normally only reserved for rhythm games like Rhythm Paradise. Getting gold medals in the game is kind of awkward (because of how the scoring system was designed) but was ultimately very rewarding. The Zodiac Riddles create a very interesting reward system, and it further underlines the mystery beneath the game.

Gris

It’s artsy, wonderful, and also very metaphorical. It does everything it needs to do quite well, and some of the puzzles are actually pretty interesting. This is one of those rare games where exploration in itself is just incredibly rewarding on its own, you always want to see the next surprise the game will throw at you, and usually the game does that very elegantly.

Pokemon Sword

I did not expect a Pokemon game to captivate me as much as this latest entry in the series, but it has clicked with me immensely well. The story is dull, but this entry finally makes the competitive aspect of Pokemon accessible enough for me to care about, after a decade (since my first Pokemon game was Diamond) of UX Design “Two steps forwards and one step back”. The connective motif of the Pokemon series is at its strongest ever, now that all multiplayer functionality is now available both locally and online, and players can cooperate in Raid battles.

Baba is You

I guess I got kind of burned out on puzzle games, but Baba is You really invigorated that love by making the game as much about programming as shoving blocks around. Although many of the games on this list so far have a sense of mystery surrounding them, but Baba is You does a really good job at creating that mystery on a system-scale level, where the rules of the game itself are mysterious yet brimming with potential. It does get complex really quickly and levels can be really hit-or-miss, but the game remains accessible enough for me.

Dicey Dungeons

Another game with very interesting system design is Dicey Dungeons, a game that I wouldn’t have expected from the Super Hexagon & VVVVVV designer as lead. Normally, I don’t have the patience for roguelikes, but this game has the wonderfully executed Episodes system that make each run different enough for me to care. It is a very refreshing take on luck and manipulating luck, filled with all kinds of silly things within.

Ys VIII: Lacrimosa of Dana

If an Ys story starts on a boat, you already know it’s going to be the butt of a joke. It’s been a while since I played an Ys game, but I got around to picking up the latest entry. I skipped a bunch of games in the series, so I’m not sure at which point the narrative in these games became basically the same as in the Trails series (a more story-focused series of games by the same developer), but it works rather well, and for the story it didn’t matter that I missed the last couple of games. Basically the action is still really nice, and the story is just a really nice bonus for the package. It drags on a bit, but most of the really annoying stuff is optional.

Catrap

Also known as Pitman, this is a really clever and elegant puzzle game, made even more impressive that it was a super early Game Boy release supporting an undo functionality and level editor. Some of the 100 puzzle rooms are kinda redundant, but across the board the puzzle quality is actually pretty impressive. I read about this in the Game Boy Works book and was intrigued enough to pick it up for €3 on the 3DS eShop, and was pleasantly suprised.

Katamari Damacy REROLL

I had missed out on this cult classic before because it never made its way to Nintendo platforms, but I’m happy to have experienced it. It’s silly, charming, and all with a very morale underneath: Earth has too much stuff. My housemates did compain that the game was too noisy, which is also a good way to describe this game as a positive thing.

Super Mario Maker 2

I’ve made over 60 courses, starting by doing the 4‑step level design that originated in the 3D Land and World games, and made a whole range of levels, from puzzles to autoscrollers and beanstalks to undergrounds. My favorite is a series of ten levels where you need to gather 999 coins within 60 minutes, which were both a blast to design and to play. Online can be a bit of a mixed bag sometimes, but just making levels already puts me in a state of flow that little games achieve for me nowadays.

WILL: A Wonderful World

The most thinky narrative game I’ve seen so far. The basic premise of the game is that you receive multiple letters from humans, and then you change the outcome of the scenario described in those letters by moving pieces up and down or between letters. This results in a lot of metagame as well, as only certain outcomes will unlock new letters. It can get pretty confusing and frustrating sometimes, but there’s nothing in there that can’t be solved by brute force.

Heaven’s Vault

A game about interpreting an old language, and all the story that surrounds it. I think this is the closest a game has come to portraying archeology… sorta accurately. It’s not exactly an Indiana Jones-style setting, but it feels much more relaxed and mysterious as you’re inside it, and all the things that can be missed while multitasking your actions. I don’t think it’s possible to play this game perfectly, which really sets the tone and game feel. I still think about the unanswered questions from the plot sometimes.

That’s it!

I ended up finishing this list a few months into 2020, so these are all the games that sticked with me. Thanks you for reading, and I am sure there will be many more games in 2020 to enjoy.

I wanted to participate in js13k for a while now, so I finally took the dive, similarly to 7drl this year. The resulting game is called BackFlipped, and you can play it on either the competition site or itch! Also, you can check out the source code on Github.

I had some goals:

• I was itching to use Zdog to make a game! Zdog is a pseudo-3D engine for 3D vector art. Minimized it’s around 29k, so it’s a bit bulky compared to the frameworks specially designed for js13k, but I can make all my other assets using code now.
• I want to work out an idea I already have spooking around in my head for a while, and I otherwise would not take the time for. Luckily, the jam theme was a good match for this idea.
• To get a js13k T‑shirt! Based on last year’s contest you need to get into the overall top 33% to win one, and I’m pretty confident I can make that!

Here’s a lengthy postmortem detailing my design decisions so I can refer to them later, but also so other people can learn! I might make a separate post about all the optimization tricks I used, but for now the js13k resources are very useful, and I tried most of the tricks listed there.

The Idea

I had an idea for a game where you fall into a well with platforms. The Left or Right arrow keys propel you into that direction, and if you hit a block, you score points. Then, you can kick through the block as well, to break it for more points.

For the “Back” theme, the extra layer I decided to add was the background. When you touch a block but then move away, it moves backwards. Once you reach the bottom of the well, gravity flips and you move to the background yourself. The better you play, the more blocks will move to the other side, increasing score potential.

I ended boosting the speed of the game during development. First blocks would disappear after leaving collision, now they do so on entering of collision to make it clearer you can kick through them. The Up key would not start a jump, but actually slow your fall. If you landed on a block you’d lose falling speed, but now you’ll just instantly start another drop after falling on something. The game is around five times faster than in the first version! Because this game has no traditional obstacles (such as spike blocks or enemies), the entire challenge has to come from battling the timer, which I think adds to the chaos of the gameplay.

Early GIF of gameplay.

Rules

My idea was to only have a set of levels, but I scrapped that and made it just an endless mode. Now it has both!

While this game has levels, each level is actually just a randomness seed set to a certain value. You can’t set a seed for randomness in JS, but you can make your own seeded system. I took one from StackOverflow. A downside is that different browsers generate other levels, but that’s not too big of an issue for this game.

At first, endless mode would make you start at a certain time, then as you’d kick blocks you’d build up a jackpot. Hitting the bottom of the level would cash out your jackpot. But it encouraged players to constantly drop straight down and not hit all platforms. I revamped it with an “All Clear” mechanic: all platforms give a little bit of time, but if you hit all the platforms on the way down, you get a couple of extra seconds as well. Endless mode also keeps getting faster and faster as you go, too, and since the level keeps growing and growing on each flip, I think there’s a pretty good game balance on this mode now.

Old interface for Jackpot mode: The +sec counter displays the jackpot value, which gets claimed when you flip around.

Interface

I don’t think many js13k participants have “making a title screen” as their top priority. For me it’s rather important, because it’s the first impression the player will get from your game. I was quite happy to be able to make a simple but cool title screen using css colors and transforms.

I didn’t want to make separate texts for desktop & mobile, so the game shows “Press Space or Tap Screen” on both platforms.

The game runs like normal in the background, except with the player, trail, and collisions disabled. Also, the title screen gets recycled as a game over screen by replacing the text. This makes the game seem more lively since it’s a screensaver when you’re not playing!

In other parts of the game the UI is minimalist:  there’s a timer, a level/score indicator, and a progress bar. A text box shows game help on the title screen and other info when needed, for example upon game saves.

I wanted a screen-filling responsive game, so I use Zdog’s zoom property to make the game fit to smaller screens, with @media rules in CSS doing the UI.

Mobile

I did not plan to enter in the Mobile category, but someone wanted me to submit a simple mobile web game as part a test, so I decided to add it to BackFlipped.

I settled on using swipe directions to input the same direction arrow key, using a GitHub gist as base. It works a bit finicky (especially with short swipes) but it’s good enough to play with one finger. You do have to swipe a lot when the game starts getting faster! I also used these controls as an excuse to add input buffering: so if the game can’t handle player input in the current step, it’ll repeat it for a couple more frames in case the player timed just a bit too early.

The version I originally submitted for js13k had broken swipe controls. Luckily, a short email to the js13k team with a new version of the game was enough to get the jam version updated!

This is pretty much how the game looks like on my older smartphone… The text isn’t very big, but at least it fits!

Faking it with Zdog

In Zdog, the 3D effect is only really visible when the camera rotates. My game didn’t require a lot of rotating though, but I decided to make the camera a little bit skewed to convey depth a bit better.

The screen flips around once you reach the bottom. I can only make the Zdog illustration rotate around its middle, which caused issues when the player was further away. The fix was making the player jump back to the origin when the camera starts flipping, then moving all other objects to the same position, relative to the player before the jump. Now the transition is super smooth!

A lot of the things that look like they’re exactly behind the player, are actually placed diagonally of that in 3D space. I did this to combat Z‑fighting, when the renderer changes in which order overlapping shapes are drawn. Now what looks neatly when watching from the game camera, is actually not placed behind each other:

You’ll notice the trail and the player are in different places, but from where the camera usually is it seems like they’re in the same place.

But it works wonderfully when watched from the game camera. And that was good enough.

Colors!

If you have a game with only flat colors, it’s a missed opportunity if you don’t add multiple palettes. I tried it in my game Mobility!, but I only ended up changing the background color, not the entire palette.

Backflipped defines six different colors: foreground and background, blocks on the fore- and background, character body/dots and eye/trail color. The background colors are most important, because everything else needs to have a decent contrast color with it.

The block colors also need good background contrast when you’re on their layer, but need to fade away into the background when they’re not: a tricky balance. So I used a palette creator designed to test the contrast of colors, and ended up making a few palettes that use the flipping mechanic of the game metaphorically: for example, Dawnbreak switches between dusk and dawn.

Coil subscribers get two extra color palettes that are unlocked from the start. I think this is a good cosmetic goodie to offer to subscribers since it doesn’t influence gameplay too much, but does look very fancy and premium. Overall, I’m very happy with the variation among these seven color palettes!

The default colors.

Strawberry Patch

Blueberry Juice

Bright & Light

Stylish Monochrome

Beau Blueprint, one of the exclusive palettes…

And Dawnbreak, the other exclusive palette.

Finishing

I kept a close eye on my minified file size at the start, manually minifying code and combining assets in a single file. Later on, I found it easier to focus on getting the game done and worry about file size later. I found it risky to start optimizing too soon, as it might make my code messier than it already is, but this benchmark gave me an idea about how big I could make the game in a month.

I zipped the game at multiple times during development, with widely fluctuating file sizes. Screenshot from WinDirStat.

As the end kept crawling closer, I tried automated linting solutions, but I couldn’t get them to work. I ended up writing a manual linter in Javascript & HTML. It allows you to paste HTML, CSS, and JS, assign filenames, and hit a button to get a single output HTML with the contents of the other files embedded. I actually ended up learning a bit about how RegEx works to minimize the code a little bit (adapting xem’s MiniMinifier), and I might expand it to be more user friendly.

Screenshot from my linter: clean files come in, messy combined file comes out. Combined with minification, this saves around 1/3th of characters!

The main way I lost file size was by removing unused Zdog functionality, like shapes I wasn’t using. Afterwards, the removals got more specific, resulting in a very messy but small version of Zdog.

I checked the game with the entry bot which helped me spot some last minute issues. Although I forgot to submit the game with the bot, manually filling the form instead. Ah well!

The full source code (except favicon) for BackFlipped. Screenshot from Visual Studio Code.

Take-away

My main realization was that, no matter how much fun it is to optimize the file size of your game, you shouldn’t forget to make the game fun to play as well. Balancing the technical and gameplay related issues was very hard, and it almost went awry, destroying my motivation for the project. Luckily, after iterating some more and having a few more testers, I did manage to make the game fun.

Finishing it was also pretty hard: thirty days for a 13kb game sounds really generous, but knowing when you should stop adding new stuff to focus on minifying and polishing what’s there was also pretty difficult. I ran into a couple of annoying last-minute bugs, but luckily I was able to get it into a shippable condition in time!

You can play BackFlipped on itch and on the js13k competition site. Also, check out any of the 244 other submissions for the jam— some really interesting games to find there, and you could fit them all on two or three floppy disks!

So I made a roguelike! I have a problem with roguelikes: the games are incredibly punishing, and usually I can’t bring up the patience to continue playing after five permadeaths or so. Also, these games can be complicated, with very little explanation—something I think is amazing in most games, but can be very frustrating in a roguelike where you’re thrown to the wolves almost instantly.

However, I have been fascinated by the genre, regardless of my inability to actually play the games. So when I saw 7drl was happening this year, I wanted to make a minimalist roguelike, also known as a roguelite. Here’s an overview of the gameplay of the game and how it was put together this way.

Hexagons

Square grids are cool, but I really wanted to try and make a game on a hex grid once. (I also opted to use hexes in Hexaria!) That means I couldn’t use pathfinding, so I’ll have to settle with some “dumber” enemy behavior.

I designed the game to be played with tank controls. By pressing forwards or backwards, you walk into the direction you’re facing into, which you can change by turning around with left or right. This way, you can navigate a hex grid while still needing just four buttons.

Moving forwards or backwards consumes a turn. I was thinking about having turning around also consuming a turn, but I think it would have made the game way too hard to be fun.

Pushing

HP is a very overdone system in games, and I wanted to try something different. There’s an enemy in one of the top-down Zelda games that is invincible, but does get knocked back a lot when attacked. They’re placed in rooms with pits. Guess what happens next.

This is what I wanted to make an entire game about, and was the first part of the game idea that would ultimately become my 7DRL entry.

A fragile world

Now that the enemy must be pushed off the stage (not unlike a Sudo wrestling match), you can start doing a lot more interesting things with level design. Here’s also where the random world generation (the trademark feature of the rougelike genre) comes in. A dynamic world is something I explored in Edge of the Sky, but while in that game the world constantly grows, in this game the world becomes ever more fragile.

The world starts off as a hexagonal shape, with ~80 hexagonal tiles. Once you progress through the game, some of those solid tiles get replaced by fragile tiles, which break after someone steps on it (either the player or an enemy). If the player reaches the flag, some of those tiles will be filled in. This part of the game was inspired by Pyoro, where your playing field grows or shrinks depending on how well you’re playing.

Slowly, the map turns into a grated cheese. It’s up to the player to prevent this as much as possible by playing carefully. This can be difficult, but they also have advantages, like acting as an extra hole to push enemies through.

Enemies

If the player has moved and the move is valid, the enemies get their turn. Each enemy type is processed in order, so each enemy of the same type gets their move, and once they’re all done, the next type of enemy is allowed to move.

The copy will face you and walk towards you if you are in their line of sight in front of them. When flanked, they’ll just turn, or if approached from the back, they won’t do anything at all. If they hit you, you get pushed back one square. If you hit them, they’ll go one square back and are stunned, meaning they can’t use their turn after yours to instantly strike back to prevent stalemates.

Since the first enemy is melee only, I wanted a ranged attacker next. The slingshot shoots arrows. It has a three turn cooldown between shooting arrows. If pushed it gets stunned, meaning the cooldown is paused, so it can’t shoot more arrows if it is attacked repeatedly. Arrows have a lifetime of around ten turns, after which they’ll disappear. If they hit the player, they get pushed back two squares.

The sniper was the last enemy to be added. It has the most powerful attack of all enemies, but cannot rotate towards you if it’s unprovoked. Once it spots you, a countdown starts, upon which a laser is fired in the direction of the player. If you’re hit, you get pushed back three squares. This enemy will also rotate towards you if you’re attacking it, meaning it can be hard to deal with in big groups of enemies.

Progression

The game is endless, there’s no level goal or credits scene. However, I did manage to put some graphs on the game over screen, tracking the turns taken, enemies defeated, and flags gathered from the last ten runs. This should give you a little idea about if you’re getting better at the game, and in which extent. This is something I wanted to try for a while now to see if it motivates players more than a normal statistics screen, and the first results are good so far, so I might use this method of indicating progression in future games.

I really wanted this game to be accessible for a lot of different player types (like my precision platformer Mobility!), but I did not manage to include all features I had planned for that, such as a setting to turn permadeath off, a difficulty selector, or a way to input a randomness seed. Features that did make it in include the fact that the game has no text (in stark contrast to most rougelikes), the fact that you can play the game with the arrow keys, WASD, ZQSD and a controller, and the fact that the game has no randomness except for the level generation. The “textless” restriction also prompted me to use a hexagon symbol (⬣) as name for the game. (Hexagone was a close second, but fell through when I found out that was already the name for a French swimming pool appliance manufacturer.)

The game starts with a controls tutorial, then introduces all enemies until you hit level 7, after which more enemies keep spawning and the world becomes more fragile. The highest score I had was around 12 flags, but Unidrax managed to hit 22 flags!

Graphics & Audio

I like isometric perspectives drawn really low-fi. I figured out quickly that staring at a static hexagon grid is pretty boring, so it needed some life implanted into it.

First, I made the grid tiles wiggle up and down a bit. This is not very noticeable—the effect used to be more intense, but I dialed it back a ton to prevent it from becoming too distracting.

There are a lot of things around the platform that float as well—I finally figured out how to set a sinus up correctly to do get a “float” effect. The background used to be the same pure black color as the tiles, but it could pretty hard to see if a tile was gone if the colors where the same.

The game has a lot of visual effects, like enemies and tiles spawning in, tiles being blown out or falling down, slashing animations, lasers, and of course screenshake. All of this is to help the player understand how the game works, and give them appropiate feedback. Especially the tile generation animation, which plays when you’re at a goal tile, takes a bit of time (although that’s also to prevent the game from breaking when that happens too fast!)

Here are the steps I took to get audio into this game, or my guide on how to do audio design when time is of the essence:

1) Find a nice track in the Free Music Archive that’s in the CC-BY and fits well with your theme, then include it in your game, put it in the credits, and set it to loop at the start of the game.

2) Find a couple of nice sound effects on freesound.org that are in the public domain (so you don’t have to credit them). You do need an account to download sounds, so I recommend setting that up in advance. Here is a list of words that might be useful to know. I always sort with the shortest sounds first. Try to find a large bundle with the kind of sounds you’re looking for.

3) Put the sounds in Audacity for quick maintenance (trim away silent parts or parts of the sound you don’t need).

4) Put all sounds in the game, and assign them to the correct actions. Also set a pitch for when the sound effect plays. If it’s a sound you hear often, randomly select the pitch from a range. If multiple entities can play the sound (like the player and the enemy), set the same sound effect, but with a different pitch for both.)

5) Play the game, and tone down the volume or pitch of sounds you think are too dominant in the soundscape (especially if you hear them often). Play the game for a bit and watch for bits where a certain sound effect gets tiring, or places where you an audio cue is still missing.

Conclusion

This became a long post! Mostly, I’m just really happy I managed to make such a strategically interesting game within such a short time. I was able to try out a lot of ideas I had that happened to work really well together. This is also my first step into rougelike territory with emergent gameplay and random worlds, and it might be something I’ll explore another time as well.

You can play ⬣ on itch.io.

Like last years’ lists, this just list games I played this year, not necessarily games that released this year, in no particular order. Also, only itch embeds this year because I’ve played a lot more games on itch, but also because all Steam embeds from last year’s list broke and I’m too lazy to add links/embeds for everything this time around.

It’s long, so you can skip straight to the Honorable Mentions and Books. Also, here’s 2017’s list.

Pipe Push Paradise

My favorite puzzle game this year. It’s really clever and brings back a lot of memories from other puzzle games. This dev also released Hiding Spot this year as well, which is also a really good puzzle game, which is a bit rougher around the edges but still every bit as interesting and smart.

My favorite Puzzlescript game this year was Sliding Ground (from Rosden’s amazing one-puzzle-game-a-day project). Hanano Puzzle 2 also deserves a mention.

The Zium Garden

My favorite walking sim this year, although The Crows Crows Crows Community Museum was a close second. Basically what it says on the tin, it’s a virtual museum that you can explore and admire without noisy other guests, and also houses art not possible in physical spaces. Check it out!

Tacoma

An excellent continuation on Gone Home. You’re asked to investigate what happened to the crew of a deserted space station by watching back AR recordings. Soon you’ll figure out how the inhabitants made the sterile environment of the Tacoma feel more homely, and what’s really been going on in there.

Runner3

I was a big fan of Runner2, and Runner3 is a really interesting continuation of the series! It has a lot more weirdness and interesting level designs, and as a result there’s a bit less quantity and a lot more quality overall. It received a nice update adding a lot more control over the difficulty settings, so try it!

Also, has no one been figuring out the secret of that radio tower yet?

Celeste

Celeste is the best thing that happened to the genre in easily five years. It feels really nice to play, level design is really tight, has one of the most original and not-gimmicky feeling level mechanics, and there’s an awesome story to serve as metaphor for all of those. And it has a nice Assist Mode that makes it really accessible for new players in the genre. And that soundtrack.

Dr Darley and the Prisoners at Santa’s Workshop

I played the first game in the series (Dr. Darley and the Case of the Deboned Children) last year and thought it was pretty neat. The sequel improves the narrative in nearly every way with an awesome soundtrack, really good jokes, and funny Dutch stereotypes.

Super Smash Bros. Ultimate

Smash Bros actually released in the year it was announced! I don’t think I have anything to add on what the critics have already said, except that its UX is top-notch yet again (just look at that main menu). I do hope Sakurai gets to work on something new after this, though.

Lumines Remastered

I missed Lumines when it originally released due to it being PlayStation only—glad I finally get to play this one. Basically it’s a Tetris-style puzzle game that only allows you to drop 2x2 blocks that can only have two different colors of blocks. They disappear when you place them in 2x2 squares (or larger rectangles) when the beat marker moves over, which is synced to the music. And that music is really good!

Persona 5

Persona 5 just oozes style. Its story is pretty good, and I like the persistent dungeons much better than Persona 4’s generated ones. This game is a masterclass for UI design and narrative as well.

Opus Magnum

This is another really good puzzle game. I was eying Zachtronics games for a while, and this is the first one that seemed accessible enough. It’s puzzle difficulty ramps up really well, and the amount of creativity allowed in solutions is liberating when compared to Sokoban-likes. And it’s also an excellent excuse to show off my solution GIFs:

Opus Magnum — Precision Machine Oil (300G, 51, 20, 2018–04-04–17-42–13)

Opus Magnum — Waterproof Sealant (2018–03-01–13-14–45)

Opus Magnum — Face Powder (2018–02-09–00-21–13)

Opus Magnum — Refined Gold (2018–03-01–12-45–22)

Furi

A shoot-em-up with only boss battles! Does that sound awesome to you? Then you’ll probably like this.

The Legend Of Zelda

The original NES one! I did obtain a original NES this year, but since I still only have one game on loan for it, I started playing Zelda with the Switch NES app. I think the Zelda games on the GameBoy are still my favorites, but seeing the true classic Zelda for the first time allowed me to truly understand the core of the series. And save states make the gambling minigame really easy!

Honorable Mentions

Okami HD: I decided to replay it this year, and am pretty amazed how timeless it is. There were some good parts in there that I’d forgotten in the years since I first played it.

N++: Basically on the other side of the precision platformer spectrum from Celeste, N++ focuses highly on quantity over quality. And it’s pretty good at that, although it’s game feel and level design can feel much more frustrating.

Jackbox Party Pack 5: Jackbox keeps re-inventing what party games should be and they’re doing a really good job at that. Jackbox continues to be a popular game of choice on my LAN parties.

Fe: The atmosphere in this game is really nice. I really wish it focused more on walking around looking at pretty environments than stealth gameplay. Climbing trees and then flying away feels really nice and makes exploring the world (especially the more vertical areas) really fun.

RiME: Another exploration-heavy game which was also really relaxing and mysterious. I didn’t really like the puzzles, though.

Taiko no Tatsujin: The Switch is getting some really good rhythm games, and this was the most prominent one to release this year. I have a couple of friends who love osu!‘s Taiko mode, so inviting those over to play it on launch day was a no-brainer.

Pinball FX3: I think I got around ten tables this year, mostly because they finally started getting discounted. The design of most cabinets is really good, although it varies from table to table how easy it is to learn the rules and get stuff done. Which makes the RPG-inspired table my favorite, probably.

Hollow Knight: It’s a good metroidvania. It’s hard in all the right ways.

Dandara: Also a metroidvania, but you’ll be jumping through spaces without gravity, jumping from wall to wall. The game is inspired by Brazilian folklore and that really feeds everything in the game. Some of the stuff in this game is annoying, but most of it is awesome.

West of Loathing: Good jokes. Seriously, just about everything in this game is one big joke. If you’re into that, this comes highly recommended.

Gorogoa: This was a really good vacation game. (Where other people bring books on vacations, I bring both books and games!) The game does a really good job at making everything mysterious, including the puzzles. Normally I hate point-and-click style puzzles in favor of more logically based puzzles (like Sokoban), but this game strikes a very good balance between the two. It’s pretty simillar to Framed (1 and 2), which I also played and feels very similar but with more consistent rules.

Child of Light: Started replaying this on Hard mode, which is actually pretty hard when you don’t play it in New Game+. Still pretty surprised by how well it hold up over the past years.

Night in the Woods: There are some really good skits in this, and while exploring the town can become a routine after a while, it’s really nice to get into the flow of meeting everyone every day. Get it on itch.

Just Shapes & Beats: The story mode in this is amazing, and the online mode can be fun to play in bursts. It’s also still receiving updates, so there’s something to look forward to every now and then.

Shantae: Half Genie Hero: It’s a decent game where the art and music is very good and the rest is just so-so. It does have a huge deal of expansions (I got the boxed Switch version with all of them included), and while there’s so much content recycled between the expansions, sometimes in interesting ways, but often it can feel like a chore with lots of backtracking.

Typeshift: This has become my go-to mobile game, replacing Nitrome’s Leap Day as my first pick. The daily puzzles can be really fun to figure out together with someone else.

Alto’s Odyssey: Zen mode can be super relaxing to play on the train after a busy week. I don’t really care about the other modes, since you can crash so quickly! I usually play until the (amazing) music has looped around two to three times.

Books!

I really like Nicky Case’s yearly book lists (here’s 2018’s), so let me add the three books I liked the most this year:

The Happy Brain (Dean Burnett)

I really liked The Idiot Brain (the predecessor for this book, which I read two years ago), so my brain instantly recognized the sequel in the store and motivated my body to part with some monetary gain in exchange for some facts about our gray mass. This time, it’s less about weird & random facts about the brain, and more about coherent info about how your brain works to keep you happy, and which things it needs to keep you motivated.

You might be able to take some life lessons out of this, but mostly, it’s fascinating, funny, and really relatable. My favorite part of these books are absolutely the funny metaphors, and how well they can get the point across. Both books are a good recommendation if you want to figure out how you work, and also how others work, why you think you’re dumb while you can actually be quite smart (as well as the other way around), and more!

Over straatnamen met name (René Dings)

This is a Dutch book about the design of street names! (I’d translate the title as “Namely about street names”.) Street names sound really boring (especially if you live in the US, where apparently Second Street is the most common street name), but it’s actually a really well thought out area of design.

From this book, I learned that streets can only be named after persons if that person has been dead for at least five years (to prevent that person from becoming evil and ruining the street the name belongs to), districts have a special council for street names that meet a couple of times a year (that you can submit suggestions to), and there’s even a neighborhood in the Netherlands with streets named after Tolkien characters! After this, I was even able to find a list with street names for my own home village, and they reflect the history of the town like a mirror.

How Emotions Are Made (Lisa Feldman Barrett)

What if everything science thought about emotions was wrong? This books goes into huge lengths to describe why our current understanding of emotions severely limits our ability to correctly judge emotions from facial expressions and body language alone, how lawyers give out larger sentences just before lunch because their hunger is clouding their judgment, and how basically everyone is misinterpreting their own emotions (like the author herself getting feverish during a date, only to find out the next day she actually had a fever).

Basically, the book argues that a new framework for emotions is needed, where emotion concepts in different cultures are respected and people can make their own emotions by assigning words for a feeling. For example, I have an emotion concept for the feeling I have when my train departs from the station, since it feels really calm but also conclusive, and the actual motion of the train also makes me feel a bit funny. I don’t feel like I agree with everything in this book, but it put my mind to work good enough to deserve a place on this list.

Next year

I am not really looking forward to any games next year (maybe Baba is You?), although now I have a NES I’ll probably start dabbling with retro games more. I expect my usage of itch to continue, and my usage of Steam to decline, just like last year. I got a load of games for my Switch this year, and that will probably be a constant next year! (Also, I still wanna play Gris!)

Also, I hope to finally be able to release new side projects to follow up Mobility. Stay tuned!